From 380d634308a5e2054dbe459036648056a62c7d24 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sun, 5 May 2019 07:25:26 -0400 Subject: [PATCH 01/41] Fix TextField dragging for highlighting text. Add more error messages to plugin::logIn. --- include/ui/TextField.hpp | 2 +- src/plugin.cpp | 31 +++++++++++++++++++------------ src/ui/TextField.cpp | 10 ++++------ 3 files changed, 24 insertions(+), 19 deletions(-) diff --git a/include/ui/TextField.hpp b/include/ui/TextField.hpp index 1fa54e0b..73d6670a 100644 --- a/include/ui/TextField.hpp +++ b/include/ui/TextField.hpp @@ -21,7 +21,7 @@ struct TextField : widget::OpaqueWidget { TextField(); void draw(const DrawArgs &args) override; - void onHover(const event::Hover &e) override; + void onDragHover(const event::DragHover &e) override; void onButton(const event::Button &e) override; void onSelectText(const event::SelectText &e) override; void onSelectKey(const event::SelectKey &e) override; diff --git a/src/plugin.cpp b/src/plugin.cpp index 352cd084..fcabc720 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -390,6 +390,7 @@ void destroy() { } void logIn(const std::string &email, const std::string &password) { + loginStatus = "Logging in..."; json_t *reqJ = json_object(); json_object_set(reqJ, "email", json_string(email.c_str())); json_object_set(reqJ, "password", json_string(password.c_str())); @@ -398,22 +399,28 @@ void logIn(const std::string &email, const std::string &password) { json_t *resJ = network::requestJson(network::POST, url, reqJ); json_decref(reqJ); - if (resJ) { - json_t *errorJ = json_object_get(resJ, "error"); - if (errorJ) { - const char *errorStr = json_string_value(errorJ); - loginStatus = errorStr; + if (!resJ) { + loginStatus = "No response from server"; + return; + } + + json_t *errorJ = json_object_get(resJ, "error"); + if (errorJ) { + const char *errorStr = json_string_value(errorJ); + loginStatus = errorStr; + } + else { + json_t *tokenJ = json_object_get(resJ, "token"); + if (tokenJ) { + const char *tokenStr = json_string_value(tokenJ); + settings::token = tokenStr; + loginStatus = ""; } else { - json_t *tokenJ = json_object_get(resJ, "token"); - if (tokenJ) { - const char *tokenStr = json_string_value(tokenJ); - settings::token = tokenStr; - loginStatus = ""; - } + loginStatus = "No token in response"; } - json_decref(resJ); } + json_decref(resJ); } void logOut() { diff --git a/src/ui/TextField.cpp b/src/ui/TextField.cpp index 12ce1f37..56645062 100644 --- a/src/ui/TextField.cpp +++ b/src/ui/TextField.cpp @@ -30,14 +30,12 @@ void TextField::draw(const DrawArgs &args) { nvgResetScissor(args.vg); } -void TextField::onHover(const event::Hover &e) { - OpaqueWidget::onHover(e); +void TextField::onDragHover(const event::DragHover &e) { + OpaqueWidget::onDragHover(e); - if (this == APP->event->draggedWidget) { + if (e.origin == this) { int pos = getTextPosition(e.pos); - if (pos != selection) { - cursor = pos; - } + cursor = pos; } } From 0ccfc845391ab925e06dfa3b87c8851c1eeb0b98 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 6 May 2019 04:27:37 -0400 Subject: [PATCH 02/41] Add GPLv3 license text. --- LICENSE-GPLv3.txt | 674 ++++++++++++++++++++++++++++++++++++++++++++++ LICENSE.md | 23 +- 2 files changed, 695 insertions(+), 2 deletions(-) create mode 100644 LICENSE-GPLv3.txt diff --git a/LICENSE-GPLv3.txt b/LICENSE-GPLv3.txt new file mode 100644 index 00000000..f288702d --- /dev/null +++ b/LICENSE-GPLv3.txt @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/LICENSE.md b/LICENSE.md index 68955249..a5a83f34 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,10 +1,29 @@ # VCV Rack Licenses -All **source code** is copyright © 2019 Andrew Belt and licensed under the [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause). -This allows open- and closed-source plugins to freely compile Rack header files into their binaries. +All VCV Rack **source code** is copyright © 2019 Andrew Belt and licensed under the [GNU General Public License v3.0](LICENSE-GPLv3.txt). + +``` +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. + +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 . +``` + +A non-commercial plugin license exception and commercial plugin licensing are pending and will be available as soon as their texts are finalized (as of 2019-05-06). + +--- Licenses of **third-party libraries** are listed in [LICENSE-dist.txt](LICENSE-dist.txt). +--- + The **Component Library graphics** in the `res/ComponentLibrary` directory are copyright © 2019 [Grayscale](http://grayscale.info/) and licensed under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/). You may not freely sell plugins using Component Library graphics. However, a free commercial license is available for plugins sold through the [VCV Store](https://vcvrack.com/plugins.html). From e9ac9eb67789c20971f3712b45bd0dc1e577340a Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 6 May 2019 05:55:32 -0400 Subject: [PATCH 03/41] Add -p for creating screenshots of every module. --- dep/Makefile | 2 +- helper.py | 3 +++ include/window.hpp | 2 ++ src/dep.cpp | 3 +++ src/main.cpp | 19 +++++++++----- src/window.cpp | 65 ++++++++++++++++++++++++++++++++++++++++++---- 6 files changed, 82 insertions(+), 12 deletions(-) diff --git a/dep/Makefile b/dep/Makefile index b0180fad..5f0cd941 100755 --- a/dep/Makefile +++ b/dep/Makefile @@ -160,7 +160,7 @@ $(rtaudio): $(MAKE) -C rtaudio/build $(MAKE) -C rtaudio/build install -$(nanovg): $(wildcard nanovg/src/*.h) +$(nanovg): $(wildcard nanovg/src/*.h) nanovg/example/stb_image_write.h cp $^ include/ $(nanosvg): $(wildcard nanosvg/src/*.h) diff --git a/helper.py b/helper.py index e7d029b6..c03b4c7d 100755 --- a/helper.py +++ b/helper.py @@ -134,6 +134,9 @@ Plugin *pluginInstance; void init(Plugin *p) { pluginInstance = p; + // Add modules here, e.g. + // p->addModel(modelMyModule); + // Any other plugin initialization may go here. // As an alternative, consider lazy-loading assets and lookup tables when your module is created to reduce startup times of Rack. } diff --git a/include/window.hpp b/include/window.hpp index 814af647..d6d20a35 100644 --- a/include/window.hpp +++ b/include/window.hpp @@ -98,6 +98,8 @@ struct Window { Window(); ~Window(); void run(); + /** Takes a screenshot of each module */ + void screenshot(); void close(); void cursorLock(); void cursorUnlock(); diff --git a/src/dep.cpp b/src/dep.cpp index 4dbe668b..3a677cdd 100644 --- a/src/dep.cpp +++ b/src/dep.cpp @@ -21,3 +21,6 @@ #define NANOSVG_IMPLEMENTATION #define NANOSVG_ALL_COLOR_KEYWORDS #include + +#define STB_IMAGE_WRITE_IMPLEMENTATION +#include diff --git a/src/main.cpp b/src/main.cpp index 95322123..44acd81a 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -57,11 +57,12 @@ int main(int argc, char *argv[]) { #endif std::string patchPath; + bool screenshot = false; // Parse command line arguments int c; opterr = 0; - while ((c = getopt(argc, argv, "ds:u:")) != -1) { + while ((c = getopt(argc, argv, "dhps:u:")) != -1) { switch (c) { case 'd': { settings::devMode = true; @@ -69,6 +70,9 @@ int main(int argc, char *argv[]) { case 'h': { settings::headless = true; } break; + case 'p': { + screenshot = true; + } break; case 's': { asset::systemDir = optarg; } break; @@ -154,15 +158,18 @@ int main(int argc, char *argv[]) { INFO("Starting engine"); APP->engine->start(); - if (!settings::headless) { + if (settings::headless) { + // TEMP Prove that the app doesn't crash + std::this_thread::sleep_for(std::chrono::seconds(2)); + } + else if (screenshot) { + APP->window->screenshot(); + } + else { INFO("Running window"); APP->window->run(); INFO("Stopped window"); } - else { - // TEMP Prove that the app doesn't crash - std::this_thread::sleep_for(std::chrono::seconds(2)); - } INFO("Stopping engine"); APP->engine->stop(); diff --git a/src/window.cpp b/src/window.cpp index f7749448..a1262550 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -7,17 +7,20 @@ #include "app.hpp" #include "patch.hpp" #include "settings.hpp" +#include "plugin.hpp" // used in Window::screenshot +#include "system.hpp" // used in Window::screenshot #include #include #include #if defined ARCH_MAC - // For CGAssociateMouseAndMouseCursorPosition - #include +// For CGAssociateMouseAndMouseCursorPosition +#include #endif #include +#include namespace rack { @@ -271,6 +274,9 @@ Window::Window() { osdialog_message(OSDIALOG_ERROR, OSDIALOG_OK, "Could not initialize NanoVG. Does your graphics card support OpenGL 2.0 or greater? If so, make sure you have the latest graphics drivers installed."); exit(1); } + + // Load default Blendish font + uiFont = loadFont(asset::system("res/fonts/DejaVuSans.ttf")); } Window::~Window() { @@ -300,10 +306,8 @@ Window::~Window() { } void Window::run() { - uiFont = APP->window->loadFont(asset::system("res/fonts/DejaVuSans.ttf")); - frame = 0; - while(!glfwWindowShouldClose(win)) { + while (!glfwWindowShouldClose(win)) { frameTimeStart = glfwGetTime(); // Make event handlers and step() have a clean nanovg context @@ -399,6 +403,57 @@ void Window::run() { } } +void Window::screenshot() { + // Iterate plugins and create directories + std::string screenshotsDir = asset::user("screenshots"); + system::createDirectory(screenshotsDir); + for (plugin::Plugin *p : plugin::plugins) { + std::string dir = screenshotsDir + "/" + p->slug; + system::createDirectory(dir); + for (plugin::Model *model : p->models) { + std::string filename = dir + "/" + model->slug + ".png"; + // Skip model if screenshot already exists + if (system::isFile(filename)) + continue; + INFO("Screenshotting %s %s to %s", p->slug.c_str(), model->slug.c_str(), filename.c_str()); + + // Create widgets + app::ModuleWidget *mw = model->createModuleWidgetNull(); + widget::FramebufferWidget *fb = new widget::FramebufferWidget; + fb->addChild(mw); + float zoom = 2.f; + fb->scale = math::Vec(zoom, zoom); + + // Draw to framebuffer + frameTimeStart = glfwGetTime(); + fb->step(); + nvgluBindFramebuffer(fb->fb); + + // Read pixels + int width, height; + nvgImageSize(vg, fb->getImageHandle(), &width, &height); + uint8_t data[height * width * 4]; + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data); + + // Flip image vertically + for (int y = 0; y < height / 2; y++) { + int flipY = height - y - 1; + uint8_t tmp[width * 4]; + memcpy(tmp, &data[y * width * 4], width * 4); + memcpy(&data[y * width * 4], &data[flipY * width * 4], width * 4); + memcpy(&data[flipY * width * 4], tmp, width * 4); + } + + // Write pixels to PNG + stbi_write_png(filename.c_str(), width, height, 4, data, width * 4); + + // Cleanup + nvgluBindFramebuffer(NULL); + delete fb; + } + } +} + void Window::close() { glfwSetWindowShouldClose(win, GLFW_TRUE); } From fa1c70220db775c4aeb0e9487927437167fad61d Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Tue, 7 May 2019 11:22:40 -0400 Subject: [PATCH 04/41] Add plugin update menu items. --- include/plugin.hpp | 11 +++++++-- src/app/MenuBar.cpp | 34 +++++++++++++++++++--------- src/plugin.cpp | 54 ++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 82 insertions(+), 17 deletions(-) diff --git a/include/plugin.hpp b/include/plugin.hpp index e727bc44..a2073ba7 100644 --- a/include/plugin.hpp +++ b/include/plugin.hpp @@ -14,12 +14,18 @@ namespace rack { namespace plugin { +struct Update { + std::string pluginSlug; + std::string version; +}; + + void init(); void destroy(); void logIn(const std::string &email, const std::string &password); void logOut(); -void query(); -void sync(); +void queryUpdates(); +void syncUpdates(); void cancelDownload(); bool isLoggedIn(); Plugin *getPlugin(const std::string &pluginSlug); @@ -33,6 +39,7 @@ extern const std::set allowedTags; extern std::vector plugins; extern std::string loginStatus; +extern std::vector updates; extern float downloadProgress; extern std::string downloadName; diff --git a/src/app/MenuBar.cpp b/src/app/MenuBar.cpp index d1205242..0059ad4a 100644 --- a/src/app/MenuBar.cpp +++ b/src/app/MenuBar.cpp @@ -562,24 +562,38 @@ struct PluginsMenu : ui::Menu { void refresh() { clearChildren(); - if (0) { - ui::ProgressBar *downloadProgressBar = new ui::ProgressBar; - downloadProgressBar->quantity = new DownloadQuantity; - addChild(downloadProgressBar); - } - else if (plugin::isLoggedIn()) { + if (plugin::isLoggedIn()) { ManageItem *manageItem = new ManageItem; manageItem->text = "Manage"; addChild(manageItem); + LogOutItem *logOutItem = new LogOutItem; + logOutItem->text = "Log out"; + addChild(logOutItem); + SyncItem *syncItem = new SyncItem; syncItem->text = "Update all"; - syncItem->disabled = true; addChild(syncItem); - LogOutItem *logOutItem = new LogOutItem; - logOutItem->text = "Log out"; - addChild(logOutItem); + if (!plugin::updates.empty()) { + addChild(new ui::MenuEntry); + + ui::MenuLabel *updatesLabel = new ui::MenuLabel; + updatesLabel->text = "Updates"; + addChild(updatesLabel); + + for (plugin::Update &update : plugin::updates) { + ui::MenuItem *updateItem = new ui::MenuItem; + updateItem->disabled = true; + updateItem->text = update.pluginSlug; + plugin::Plugin *p = plugin::getPlugin(update.pluginSlug); + if (p) { + updateItem->rightText += "v" + p->version + " → "; + } + updateItem->rightText += "v" + update.version; + addChild(updateItem); + } + } } else { RegisterItem *registerItem = new RegisterItem; diff --git a/src/plugin.cpp b/src/plugin.cpp index fcabc720..d7b9743b 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -369,6 +369,13 @@ void init() { extractZip(fundamentalSrc.c_str(), pluginsDir.c_str()); loadPlugin(fundamentalDir); } + + // TEMP + // Sync in a detached thread + std::thread t([]{ + queryUpdates(); + }); + t.detach(); } void destroy() { @@ -427,9 +434,10 @@ void logOut() { settings::token = ""; } -void query() { +void queryUpdates() { if (settings::token.empty()) return; + updates.clear(); // Get user's plugins list json_t *pluginsReqJ = json_object(); @@ -464,8 +472,45 @@ void query() { json_decref(manifestsResJ); }); - json_dumpf(pluginsResJ, stderr, JSON_INDENT(2)); - json_dumpf(manifestsResJ, stderr, JSON_INDENT(2)); + json_t *manifestsJ = json_object_get(manifestsResJ, "manifests"); + json_t *pluginsJ = json_object_get(pluginsResJ, "plugins"); + + size_t pluginIndex; + json_t *pluginJ; + json_array_foreach(pluginsJ, pluginIndex, pluginJ) { + Update update; + // Get plugin manifest + update.pluginSlug = json_string_value(pluginJ); + json_t *manifestJ = json_object_get(manifestsJ, update.pluginSlug.c_str()); + if (!manifestJ) { + WARN("VCV account has plugin %s but no manifest was found", update.pluginSlug.c_str()); + continue; + } + + // Get version + // TODO Change this to "version" when API changes + json_t *versionJ = json_object_get(manifestJ, "latestVersion"); + if (!versionJ) { + WARN("Plugin %s has no version in manifest", update.pluginSlug.c_str()); + continue; + } + update.version = json_string_value(versionJ); + + // Check status + json_t *statusJ = json_object_get(manifestJ, "status"); + if (!statusJ) + continue; + std::string status = json_string_value(statusJ); + if (status != "available") + continue; + + // Check if update is needed + Plugin *p = getPlugin(update.pluginSlug); + if (p && p->version == update.version) + continue; + + updates.push_back(update); + } } void sync() { @@ -473,8 +518,6 @@ void sync() { if (settings::token.empty()) return false; - bool available = false; - if (!dryRun) { downloadProgress = 0.0; downloadName = "Updating plugins..."; @@ -654,6 +697,7 @@ bool isSlugValid(const std::string &slug) { std::vector plugins; std::string loginStatus; +std::vector updates; float downloadProgress = 0.f; std::string downloadName; From 9d6ee7c070af1d852cde9165a3d043dd467fc0de Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Tue, 7 May 2019 11:54:13 -0400 Subject: [PATCH 05/41] Open changelog in browser if UpdateItem is clicked in the plugin menubar. --- include/plugin.hpp | 1 + src/app/MenuBar.cpp | 17 ++++++++++++++--- src/plugin.cpp | 14 ++++++++++---- 3 files changed, 25 insertions(+), 7 deletions(-) diff --git a/include/plugin.hpp b/include/plugin.hpp index a2073ba7..1fc55184 100644 --- a/include/plugin.hpp +++ b/include/plugin.hpp @@ -17,6 +17,7 @@ namespace plugin { struct Update { std::string pluginSlug; std::string version; + std::string changelogUrl; }; diff --git a/src/app/MenuBar.cpp b/src/app/MenuBar.cpp index 0059ad4a..c6fa057f 100644 --- a/src/app/MenuBar.cpp +++ b/src/app/MenuBar.cpp @@ -487,6 +487,16 @@ struct SyncItem : ui::MenuItem { } }; +struct UpdateItem : ui::MenuItem { + std::string changelogUrl; + void onAction(const event::Action &e) override { + std::thread t([=]() { + system::openBrowser(changelogUrl); + }); + t.detach(); + } +}; + #if 0 struct SyncButton : ui::Button { bool checked = false; @@ -579,18 +589,19 @@ struct PluginsMenu : ui::Menu { addChild(new ui::MenuEntry); ui::MenuLabel *updatesLabel = new ui::MenuLabel; - updatesLabel->text = "Updates"; + updatesLabel->text = "Updates (click for changelog)"; addChild(updatesLabel); for (plugin::Update &update : plugin::updates) { - ui::MenuItem *updateItem = new ui::MenuItem; - updateItem->disabled = true; + UpdateItem *updateItem = new UpdateItem; updateItem->text = update.pluginSlug; plugin::Plugin *p = plugin::getPlugin(update.pluginSlug); if (p) { updateItem->rightText += "v" + p->version + " → "; } updateItem->rightText += "v" + update.version; + updateItem->changelogUrl = update.changelogUrl; + updateItem->disabled = update.changelogUrl.empty(); addChild(updateItem); } } diff --git a/src/plugin.cpp b/src/plugin.cpp index d7b9743b..9884bd5c 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -496,6 +496,11 @@ void queryUpdates() { } update.version = json_string_value(versionJ); + // Check if update is needed + Plugin *p = getPlugin(update.pluginSlug); + if (p && p->version == update.version) + continue; + // Check status json_t *statusJ = json_object_get(manifestJ, "status"); if (!statusJ) @@ -504,10 +509,11 @@ void queryUpdates() { if (status != "available") continue; - // Check if update is needed - Plugin *p = getPlugin(update.pluginSlug); - if (p && p->version == update.version) - continue; + // Get changelog URL + json_t *changelogUrlJ = json_object_get(manifestJ, "changelogUrl"); + if (changelogUrlJ) { + update.changelogUrl = json_string_value(changelogUrlJ); + } updates.push_back(update); } From 432aa9023ee8089d4750e9b4a07300b68efb28c3 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Tue, 7 May 2019 13:23:46 -0400 Subject: [PATCH 06/41] Initial functionality for plugin::syncUpdates(). --- src/app/MenuBar.cpp | 7 ++- src/plugin.cpp | 126 +++++++------------------------------------- 2 files changed, 26 insertions(+), 107 deletions(-) diff --git a/src/app/MenuBar.cpp b/src/app/MenuBar.cpp index c6fa057f..c2b4c77b 100644 --- a/src/app/MenuBar.cpp +++ b/src/app/MenuBar.cpp @@ -484,6 +484,10 @@ struct ManageItem : ui::MenuItem { struct SyncItem : ui::MenuItem { void onAction(const event::Action &e) override { + std::thread t([=]() { + plugin::syncUpdates(); + }); + t.detach(); } }; @@ -583,6 +587,7 @@ struct PluginsMenu : ui::Menu { SyncItem *syncItem = new SyncItem; syncItem->text = "Update all"; + syncItem->disabled = plugin::updates.empty(); addChild(syncItem); if (!plugin::updates.empty()) { @@ -592,7 +597,7 @@ struct PluginsMenu : ui::Menu { updatesLabel->text = "Updates (click for changelog)"; addChild(updatesLabel); - for (plugin::Update &update : plugin::updates) { + for (const plugin::Update &update : plugin::updates) { UpdateItem *updateItem = new UpdateItem; updateItem->text = update.pluginSlug; plugin::Plugin *p = plugin::getPlugin(update.pluginSlug); diff --git a/src/plugin.cpp b/src/plugin.cpp index 9884bd5c..18b66eed 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -157,40 +157,7 @@ static bool loadPlugin(std::string path) { return true; } -static bool syncPlugin(std::string slug, json_t *manifestJ, bool dryRun) { - // Check that "status" is "available" - json_t *statusJ = json_object_get(manifestJ, "status"); - if (!statusJ) { - return false; - } - std::string status = json_string_value(statusJ); - if (status != "available") { - return false; - } - - // Get latest version - json_t *latestVersionJ = json_object_get(manifestJ, "latestVersion"); - if (!latestVersionJ) { - WARN("Could not get latest version of plugin %s", slug.c_str()); - return false; - } - std::string latestVersion = json_string_value(latestVersionJ); - - // Check whether we already have a plugin with the same slug and version - Plugin *plugin = getPlugin(slug); - if (plugin && plugin->version == latestVersion) { - return false; - } - - json_t *nameJ = json_object_get(manifestJ, "name"); - std::string name; - if (nameJ) { - name = json_string_value(nameJ); - } - else { - name = slug; - } - +static bool syncPlugin(std::string slug, std::string version) { #if defined ARCH_WIN std::string arch = "win"; #elif ARCH_MAC @@ -199,45 +166,26 @@ static bool syncPlugin(std::string slug, json_t *manifestJ, bool dryRun) { std::string arch = "lin"; #endif - std::string downloadUrl; - downloadUrl = app::API_URL; + std::string downloadUrl = app::API_URL; downloadUrl += "/download"; - if (dryRun) { - downloadUrl += "/available"; - } downloadUrl += "?token=" + network::encodeUrl(settings::token); downloadUrl += "&slug=" + network::encodeUrl(slug); - downloadUrl += "&version=" + network::encodeUrl(latestVersion); + downloadUrl += "&version=" + network::encodeUrl(version); downloadUrl += "&arch=" + network::encodeUrl(arch); - if (dryRun) { - // Check if available - json_t *availableResJ = network::requestJson(network::GET, downloadUrl, NULL); - if (!availableResJ) { - WARN("Could not check whether download is available"); - return false; - } - DEFER({ - json_decref(availableResJ); - }); - json_t *successJ = json_object_get(availableResJ, "success"); - return json_boolean_value(successJ); - } - else { - downloadName = name; - downloadProgress = 0.0; - INFO("Downloading plugin %s %s %s", slug.c_str(), latestVersion.c_str(), arch.c_str()); - - // Download zip - std::string pluginDest = asset::user("plugins/" + slug + ".zip"); - if (!network::requestDownload(downloadUrl, pluginDest, &downloadProgress)) { - WARN("Plugin %s download was unsuccessful", slug.c_str()); - return false; - } + // downloadName = name; + downloadProgress = 0.0; + INFO("Downloading plugin %s %s %s", slug.c_str(), version.c_str(), arch.c_str()); - downloadName = ""; - return true; + // Download zip + std::string pluginDest = asset::user("plugins/" + slug + ".zip"); + if (!network::requestDownload(downloadUrl, pluginDest, &downloadProgress)) { + WARN("Plugin %s download was unsuccessful", slug.c_str()); + return false; } + + // downloadName = ""; + return true; } static void loadPlugins(std::string path) { @@ -519,50 +467,16 @@ void queryUpdates() { } } -void sync() { -#if 0 +void syncUpdates() { if (settings::token.empty()) - return false; - - if (!dryRun) { - downloadProgress = 0.0; - downloadName = "Updating plugins..."; - } - - // Check each plugin in list of plugin slugs - json_t *pluginsJ = json_object_get(pluginsResJ, "plugins"); - if (!pluginsJ) { - WARN("No plugins array"); - return false; - } - json_t *manifestsJ = json_object_get(manifestsResJ, "manifests"); - if (!manifestsJ) { - WARN("No manifests object"); - return false; - } - - size_t slugIndex; - json_t *slugJ; - json_array_foreach(pluginsJ, slugIndex, slugJ) { - std::string slug = json_string_value(slugJ); - // Search for slug in manifests - const char *manifestSlug; - json_t *manifestJ = NULL; - json_object_foreach(manifestsJ, manifestSlug, manifestJ) { - if (slug == std::string(manifestSlug)) - break; - } + return; - if (!manifestJ) - continue; + downloadProgress = 0.0; + downloadName = "Updating plugins..."; - if (syncPlugin(slug, manifestJ, dryRun)) { - available = true; - } + for (const Update &update : updates) { + syncPlugin(update.pluginSlug, update.version); } - - return available; -#endif } void cancelDownload() { From fee87cddff040df43dee00cead77a401b19713ad Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Tue, 7 May 2019 13:32:25 -0400 Subject: [PATCH 07/41] Simplify RackScrollWidget scroll box computation and behavior. --- src/app/RackScrollWidget.cpp | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/src/app/RackScrollWidget.cpp b/src/app/RackScrollWidget.cpp index 44b57eb9..63728a71 100644 --- a/src/app/RackScrollWidget.cpp +++ b/src/app/RackScrollWidget.cpp @@ -34,24 +34,18 @@ void RackScrollWidget::step() { zoomPos = box.size.div(2); - // Set zoomWidget box to module bounding box + // Compute module bounding box math::Rect moduleBox = rackWidget->moduleContainer->getChildrenBoundingBox(); if (!moduleBox.size.isFinite()) moduleBox = math::Rect(RACK_OFFSET, math::Vec(0, 0)); - zoomWidget->box.pos = moduleBox.pos.mult(zoom); - zoomWidget->box.size = moduleBox.size.mult(zoom); - // Expand to moduleBox - math::Rect scrollBox = moduleBox.grow(RACK_GRID_SIZE.mult(math::Vec(50, 2))); + // Expand moduleBox by half a screen size + math::Rect scrollBox = moduleBox; scrollBox.pos = scrollBox.pos.mult(zoom); scrollBox.size = scrollBox.size.mult(zoom); + scrollBox = scrollBox.grow(box.size.div(2)); - // Expand scrollBox to center the moduleBox - math::Vec s = box.size.minus(scrollBox.size).max(math::Vec()); - scrollBox.pos = scrollBox.pos.minus(s.div(2)); - scrollBox.size = scrollBox.size.plus(s); - - // Expand to viewport size + // Expand to the current viewport box so that moving modules (and thus changing the module bounding box) doesn't clamp the scroll offset. math::Rect viewportBox; viewportBox.pos = oldOffset; viewportBox.size = box.size; From 478c8fcc7149595d31e547eb629098873f25bf9f Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Wed, 8 May 2019 10:41:53 -0400 Subject: [PATCH 08/41] Change name of driver to driverId and device to deviceId in audio namespace. --- include/audio.hpp | 20 +++---- src/Core/AudioInterface.cpp | 4 +- src/app/AudioWidget.cpp | 34 ++++++------ src/audio.cpp | 104 ++++++++++++++++++------------------ src/plugin.cpp | 14 ++--- 5 files changed, 88 insertions(+), 88 deletions(-) diff --git a/include/audio.hpp b/include/audio.hpp index 59ab47d0..1d919cfc 100644 --- a/include/audio.hpp +++ b/include/audio.hpp @@ -20,8 +20,8 @@ namespace audio { struct Port { // Stream properties - int driver = 0; - int device = -1; + int driverId = 0; + int deviceId = -1; int offset = 0; int maxChannels = 8; int sampleRate = 44100; @@ -35,17 +35,17 @@ struct Port { Port(); virtual ~Port(); - std::vector getDrivers(); - std::string getDriverName(int driver); - void setDriver(int driver); + std::vector getDriverIds(); + std::string getDriverName(int driverId); + void setDriverId(int driverId); int getDeviceCount(); - bool getDeviceInfo(int device, RtAudio::DeviceInfo *deviceInfo); + bool getDeviceInfo(int deviceId, RtAudio::DeviceInfo *deviceInfo); /** Returns the number of inputs or outputs, whichever is greater */ - int getDeviceChannels(int device); - std::string getDeviceName(int device); - std::string getDeviceDetail(int device, int offset); - void setDevice(int device, int offset); + int getDeviceChannels(int deviceId); + std::string getDeviceName(int deviceId); + std::string getDeviceDetail(int deviceId, int offset); + void setDeviceId(int deviceId, int offset); std::vector getSampleRates(); void setSampleRate(int sampleRate); diff --git a/src/Core/AudioInterface.cpp b/src/Core/AudioInterface.cpp index ec1b155a..9774b127 100644 --- a/src/Core/AudioInterface.cpp +++ b/src/Core/AudioInterface.cpp @@ -28,7 +28,7 @@ struct AudioInterfacePort : audio::Port { ~AudioInterfacePort() { // Close stream here before destructing AudioInterfacePort, so the mutexes are still valid when waiting to close. - setDevice(-1, 0); + setDeviceId(-1, 0); } void processStream(const float *input, float *output, int frames) override { @@ -227,7 +227,7 @@ struct AudioInterface : Module { } void onReset() override { - port.setDevice(-1, 0); + port.setDeviceId(-1, 0); } }; diff --git a/src/app/AudioWidget.cpp b/src/app/AudioWidget.cpp index 7fdcb34b..a423ea0a 100644 --- a/src/app/AudioWidget.cpp +++ b/src/app/AudioWidget.cpp @@ -9,9 +9,9 @@ namespace app { struct AudioDriverItem : ui::MenuItem { audio::Port *port; - int driver; + int driverId; void onAction(const event::Action &e) override { - port->setDriver(driver); + port->setDriverId(driverId); } }; @@ -23,18 +23,18 @@ struct AudioDriverChoice : LedDisplayChoice { ui::Menu *menu = createMenu(); menu->addChild(createMenuLabel("Audio driver")); - for (int driver : port->getDrivers()) { + for (int driverId : port->getDriverIds()) { AudioDriverItem *item = new AudioDriverItem; item->port = port; - item->driver = driver; - item->text = port->getDriverName(driver); - item->rightText = CHECKMARK(item->driver == port->driver); + item->driverId = driverId; + item->text = port->getDriverName(driverId); + item->rightText = CHECKMARK(item->driverId == port->driverId); menu->addChild(item); } } void step() override { if (port) - text = port->getDriverName(port->driver); + text = port->getDriverName(port->driverId); else text = "Audio driver"; } @@ -43,10 +43,10 @@ struct AudioDriverChoice : LedDisplayChoice { struct AudioDeviceItem : ui::MenuItem { audio::Port *port; - int device; + int deviceId; int offset; void onAction(const event::Action &e) override { - port->setDevice(device, offset); + port->setDeviceId(deviceId, offset); } }; @@ -65,20 +65,20 @@ struct AudioDeviceChoice : LedDisplayChoice { { AudioDeviceItem *item = new AudioDeviceItem; item->port = port; - item->device = -1; + item->deviceId = -1; item->text = "(No device)"; - item->rightText = CHECKMARK(item->device == port->device); + item->rightText = CHECKMARK(item->deviceId == port->deviceId); menu->addChild(item); } - for (int device = 0; device < deviceCount; device++) { - int channels = std::min(maxTotalChannels, port->getDeviceChannels(device)); + for (int deviceId = 0; deviceId < deviceCount; deviceId++) { + int channels = std::min(maxTotalChannels, port->getDeviceChannels(deviceId)); for (int offset = 0; offset < channels; offset += port->maxChannels) { AudioDeviceItem *item = new AudioDeviceItem; item->port = port; - item->device = device; + item->deviceId = deviceId; item->offset = offset; - item->text = port->getDeviceDetail(device, offset); - item->rightText = CHECKMARK(item->device == port->device && item->offset == port->offset); + item->text = port->getDeviceDetail(deviceId, offset); + item->rightText = CHECKMARK(item->deviceId == port->deviceId && item->offset == port->offset); menu->addChild(item); } } @@ -88,7 +88,7 @@ struct AudioDeviceChoice : LedDisplayChoice { text = "Audio device"; return; } - text = port->getDeviceDetail(port->device, port->offset); + text = port->getDeviceDetail(port->deviceId, port->offset); if (text.empty()) { text = "(No device)"; color.a = 0.5f; diff --git a/src/audio.cpp b/src/audio.cpp index f465bbb7..e9713bb6 100644 --- a/src/audio.cpp +++ b/src/audio.cpp @@ -10,14 +10,14 @@ namespace audio { Port::Port() { - setDriver(RtAudio::UNSPECIFIED); + setDriverId(RtAudio::UNSPECIFIED); } Port::~Port() { closeStream(); } -std::vector Port::getDrivers() { +std::vector Port::getDriverIds() { std::vector apis; RtAudio::getCompiledApi(apis); std::vector drivers; @@ -29,8 +29,8 @@ std::vector Port::getDrivers() { return drivers; } -std::string Port::getDriverName(int driver) { - switch (driver) { +std::string Port::getDriverName(int driverId) { + switch (driverId) { case RtAudio::UNSPECIFIED: return "Unspecified"; case RtAudio::LINUX_ALSA: return "ALSA"; case RtAudio::LINUX_PULSE: return "PulseAudio"; @@ -46,24 +46,24 @@ std::string Port::getDriverName(int driver) { } } -void Port::setDriver(int driver) { +void Port::setDriverId(int driverId) { // Close device - setDevice(-1, 0); + setDeviceId(-1, 0); // Close driver if (rtAudio) { delete rtAudio; rtAudio = NULL; } - this->driver = 0; + this->driverId = 0; // Open driver - if (driver >= 0) { - rtAudio = new RtAudio((RtAudio::Api) driver); - this->driver = (int) rtAudio->getCurrentApi(); + if (driverId >= 0) { + rtAudio = new RtAudio((RtAudio::Api) driverId); + this->driverId = (int) rtAudio->getCurrentApi(); } - else if (driver == BRIDGE_DRIVER) { - this->driver = BRIDGE_DRIVER; + else if (driverId == BRIDGE_DRIVER) { + this->driverId = BRIDGE_DRIVER; } } @@ -71,24 +71,24 @@ int Port::getDeviceCount() { if (rtAudio) { return rtAudio->getDeviceCount(); } - else if (driver == BRIDGE_DRIVER) { + else if (driverId == BRIDGE_DRIVER) { return BRIDGE_NUM_PORTS; } return 0; } -bool Port::getDeviceInfo(int device, RtAudio::DeviceInfo *deviceInfo) { +bool Port::getDeviceInfo(int deviceId, RtAudio::DeviceInfo *deviceInfo) { if (!deviceInfo) return false; if (rtAudio) { - if (device == this->device) { + if (deviceId == this->deviceId) { *deviceInfo = this->deviceInfo; return true; } else { try { - *deviceInfo = rtAudio->getDeviceInfo(device); + *deviceInfo = rtAudio->getDeviceInfo(deviceId); return true; } catch (RtAudioError &e) { @@ -100,43 +100,43 @@ bool Port::getDeviceInfo(int device, RtAudio::DeviceInfo *deviceInfo) { return false; } -int Port::getDeviceChannels(int device) { - if (device < 0) +int Port::getDeviceChannels(int deviceId) { + if (deviceId < 0) return 0; if (rtAudio) { RtAudio::DeviceInfo deviceInfo; - if (getDeviceInfo(device, &deviceInfo)) + if (getDeviceInfo(deviceId, &deviceInfo)) return std::max((int) deviceInfo.inputChannels, (int) deviceInfo.outputChannels); } - else if (driver == BRIDGE_DRIVER) { + else if (driverId == BRIDGE_DRIVER) { return std::max(BRIDGE_OUTPUTS, BRIDGE_INPUTS); } return 0; } -std::string Port::getDeviceName(int device) { - if (device < 0) +std::string Port::getDeviceName(int deviceId) { + if (deviceId < 0) return ""; if (rtAudio) { RtAudio::DeviceInfo deviceInfo; - if (getDeviceInfo(device, &deviceInfo)) + if (getDeviceInfo(deviceId, &deviceInfo)) return deviceInfo.name; } - else if (driver == BRIDGE_DRIVER) { - return string::f("%d", device + 1); + else if (driverId == BRIDGE_DRIVER) { + return string::f("%d", deviceId + 1); } return ""; } -std::string Port::getDeviceDetail(int device, int offset) { - if (device < 0) +std::string Port::getDeviceDetail(int deviceId, int offset) { + if (deviceId < 0) return ""; if (rtAudio) { RtAudio::DeviceInfo deviceInfo; - if (getDeviceInfo(device, &deviceInfo)) { + if (getDeviceInfo(deviceId, &deviceInfo)) { std::string deviceDetail = string::f("%s (", deviceInfo.name.c_str()); if (offset < (int) deviceInfo.inputChannels) deviceDetail += string::f("%d-%d in", offset + 1, std::min(offset + maxChannels, (int) deviceInfo.inputChannels)); @@ -148,15 +148,15 @@ std::string Port::getDeviceDetail(int device, int offset) { return deviceDetail; } } - else if (driver == BRIDGE_DRIVER) { - return string::f("Port %d", device + 1); + else if (driverId == BRIDGE_DRIVER) { + return string::f("Port %d", deviceId + 1); } return ""; } -void Port::setDevice(int device, int offset) { +void Port::setDeviceId(int deviceId, int offset) { closeStream(); - this->device = device; + this->deviceId = deviceId; this->offset = offset; openStream(); } @@ -164,7 +164,7 @@ void Port::setDevice(int device, int offset) { std::vector Port::getSampleRates() { if (rtAudio) { try { - RtAudio::DeviceInfo deviceInfo = rtAudio->getDeviceInfo(device); + RtAudio::DeviceInfo deviceInfo = rtAudio->getDeviceInfo(deviceId); std::vector sampleRates(deviceInfo.sampleRates.begin(), deviceInfo.sampleRates.end()); return sampleRates; } @@ -218,13 +218,13 @@ static int rtCallback(void *outputBuffer, void *inputBuffer, unsigned int nFrame } void Port::openStream() { - if (device < 0) + if (deviceId < 0) return; if (rtAudio) { // Open new device try { - deviceInfo = rtAudio->getDeviceInfo(device); + deviceInfo = rtAudio->getDeviceInfo(deviceId); } catch (RtAudioError &e) { WARN("Failed to query RtAudio device: %s", e.what()); @@ -237,17 +237,17 @@ void Port::openStream() { setChannels(math::clamp((int) deviceInfo.outputChannels - offset, 0, maxChannels), math::clamp((int) deviceInfo.inputChannels - offset, 0, maxChannels)); if (numOutputs == 0 && numInputs == 0) { - WARN("RtAudio device %d has 0 inputs and 0 outputs", device); + WARN("RtAudio device %d has 0 inputs and 0 outputs", deviceId); return; } RtAudio::StreamParameters outParameters; - outParameters.deviceId = device; + outParameters.deviceId = deviceId; outParameters.nChannels = numOutputs; outParameters.firstChannel = offset; RtAudio::StreamParameters inParameters; - inParameters.deviceId = device; + inParameters.deviceId = deviceId; inParameters.nChannels = numInputs; inParameters.firstChannel = offset; @@ -263,7 +263,7 @@ void Port::openStream() { } try { - INFO("Opening audio RtAudio device %d with %d in %d out", device, numInputs, numOutputs); + INFO("Opening audio RtAudio device %d with %d in %d out", deviceId, numInputs, numOutputs); rtAudio->openStream( numOutputs == 0 ? NULL : &outParameters, numInputs == 0 ? NULL : &inParameters, @@ -276,7 +276,7 @@ void Port::openStream() { } try { - INFO("Starting RtAudio stream %d", device); + INFO("Starting RtAudio stream %d", deviceId); rtAudio->startStream(); } catch (RtAudioError &e) { @@ -288,9 +288,9 @@ void Port::openStream() { this->sampleRate = rtAudio->getStreamSampleRate(); onOpenStream(); } - else if (driver == BRIDGE_DRIVER) { + else if (driverId == BRIDGE_DRIVER) { setChannels(BRIDGE_OUTPUTS, BRIDGE_INPUTS); - bridgeAudioSubscribe(device, this); + bridgeAudioSubscribe(deviceId, this); } } @@ -299,7 +299,7 @@ void Port::closeStream() { if (rtAudio) { if (rtAudio->isStreamRunning()) { - INFO("Stopping RtAudio stream %d", device); + INFO("Stopping RtAudio stream %d", deviceId); try { rtAudio->stopStream(); } @@ -308,7 +308,7 @@ void Port::closeStream() { } } if (rtAudio->isStreamOpen()) { - INFO("Closing RtAudio stream %d", device); + INFO("Closing RtAudio stream %d", deviceId); try { rtAudio->closeStream(); } @@ -318,8 +318,8 @@ void Port::closeStream() { } deviceInfo = RtAudio::DeviceInfo(); } - else if (driver == BRIDGE_DRIVER) { - bridgeAudioUnsubscribe(device, this); + else if (driverId == BRIDGE_DRIVER) { + bridgeAudioUnsubscribe(deviceId, this); } onCloseStream(); @@ -327,8 +327,8 @@ void Port::closeStream() { json_t *Port::toJson() { json_t *rootJ = json_object(); - json_object_set_new(rootJ, "driver", json_integer(driver)); - std::string deviceName = getDeviceName(device); + json_object_set_new(rootJ, "driver", json_integer(driverId)); + std::string deviceName = getDeviceName(deviceId); if (!deviceName.empty()) json_object_set_new(rootJ, "deviceName", json_string(deviceName.c_str())); json_object_set_new(rootJ, "offset", json_integer(offset)); @@ -343,15 +343,15 @@ void Port::fromJson(json_t *rootJ) { json_t *driverJ = json_object_get(rootJ, "driver"); if (driverJ) - setDriver(json_number_value(driverJ)); + setDriverId(json_number_value(driverJ)); json_t *deviceNameJ = json_object_get(rootJ, "deviceName"); if (deviceNameJ) { std::string deviceName = json_string_value(deviceNameJ); // Search for device ID with equal name - for (int device = 0; device < getDeviceCount(); device++) { - if (getDeviceName(device) == deviceName) { - this->device = device; + for (int deviceId = 0; deviceId < getDeviceCount(); deviceId++) { + if (getDeviceName(deviceId) == deviceName) { + this->deviceId = deviceId; break; } } diff --git a/src/plugin.cpp b/src/plugin.cpp index 18b66eed..4c85387e 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -157,7 +157,7 @@ static bool loadPlugin(std::string path) { return true; } -static bool syncPlugin(std::string slug, std::string version) { +static bool syncUpdate(const Update &update) { #if defined ARCH_WIN std::string arch = "win"; #elif ARCH_MAC @@ -169,18 +169,18 @@ static bool syncPlugin(std::string slug, std::string version) { std::string downloadUrl = app::API_URL; downloadUrl += "/download"; downloadUrl += "?token=" + network::encodeUrl(settings::token); - downloadUrl += "&slug=" + network::encodeUrl(slug); - downloadUrl += "&version=" + network::encodeUrl(version); + downloadUrl += "&slug=" + network::encodeUrl(update.pluginSlug); + downloadUrl += "&version=" + network::encodeUrl(update.version); downloadUrl += "&arch=" + network::encodeUrl(arch); // downloadName = name; downloadProgress = 0.0; - INFO("Downloading plugin %s %s %s", slug.c_str(), version.c_str(), arch.c_str()); + INFO("Downloading plugin %s %s %s", update.pluginSlug.c_str(), update.version.c_str(), arch.c_str()); // Download zip - std::string pluginDest = asset::user("plugins/" + slug + ".zip"); + std::string pluginDest = asset::user("plugins/" + update.pluginSlug + ".zip"); if (!network::requestDownload(downloadUrl, pluginDest, &downloadProgress)) { - WARN("Plugin %s download was unsuccessful", slug.c_str()); + WARN("Plugin %s download was unsuccessful", update.pluginSlug.c_str()); return false; } @@ -475,7 +475,7 @@ void syncUpdates() { downloadName = "Updating plugins..."; for (const Update &update : updates) { - syncPlugin(update.pluginSlug, update.version); + syncUpdate(update); } } From 99783f9095b951409834b1feb4ef0319de81a58a Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Wed, 8 May 2019 10:51:44 -0400 Subject: [PATCH 09/41] Added zoom level to Window::screenshot(). --- include/window.hpp | 2 +- src/main.cpp | 6 ++++-- src/window.cpp | 3 +-- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/include/window.hpp b/include/window.hpp index d6d20a35..4a58d70c 100644 --- a/include/window.hpp +++ b/include/window.hpp @@ -99,7 +99,7 @@ struct Window { ~Window(); void run(); /** Takes a screenshot of each module */ - void screenshot(); + void screenshot(float zoom); void close(); void cursorLock(); void cursorUnlock(); diff --git a/src/main.cpp b/src/main.cpp index 44acd81a..46270cfa 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -58,11 +58,12 @@ int main(int argc, char *argv[]) { std::string patchPath; bool screenshot = false; + float screenshotZoom = 1.f; // Parse command line arguments int c; opterr = 0; - while ((c = getopt(argc, argv, "dhps:u:")) != -1) { + while ((c = getopt(argc, argv, "dhp:s:u:")) != -1) { switch (c) { case 'd': { settings::devMode = true; @@ -72,6 +73,7 @@ int main(int argc, char *argv[]) { } break; case 'p': { screenshot = true; + sscanf(optarg, "%f", &screenshotZoom); } break; case 's': { asset::systemDir = optarg; @@ -163,7 +165,7 @@ int main(int argc, char *argv[]) { std::this_thread::sleep_for(std::chrono::seconds(2)); } else if (screenshot) { - APP->window->screenshot(); + APP->window->screenshot(screenshotZoom); } else { INFO("Running window"); diff --git a/src/window.cpp b/src/window.cpp index a1262550..57bd5374 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -403,7 +403,7 @@ void Window::run() { } } -void Window::screenshot() { +void Window::screenshot(float zoom) { // Iterate plugins and create directories std::string screenshotsDir = asset::user("screenshots"); system::createDirectory(screenshotsDir); @@ -421,7 +421,6 @@ void Window::screenshot() { app::ModuleWidget *mw = model->createModuleWidgetNull(); widget::FramebufferWidget *fb = new widget::FramebufferWidget; fb->addChild(mw); - float zoom = 2.f; fb->scale = math::Vec(zoom, zoom); // Draw to framebuffer From d9078e3f699af7d38b0e5c99d68ff1b0398b90e4 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Wed, 8 May 2019 20:36:07 -0400 Subject: [PATCH 10/41] Allocate screenshot pixel array on heap. --- src/main.cpp | 1 + src/window.cpp | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main.cpp b/src/main.cpp index 46270cfa..f02e2e34 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -165,6 +165,7 @@ int main(int argc, char *argv[]) { std::this_thread::sleep_for(std::chrono::seconds(2)); } else if (screenshot) { + INFO("Taking screenshots of all modules at %gx zoom", screenshotZoom); APP->window->screenshot(screenshotZoom); } else { diff --git a/src/window.cpp b/src/window.cpp index 57bd5374..c215aaac 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -431,7 +431,7 @@ void Window::screenshot(float zoom) { // Read pixels int width, height; nvgImageSize(vg, fb->getImageHandle(), &width, &height); - uint8_t data[height * width * 4]; + uint8_t *data = new uint8_t[height * width * 4]; glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data); // Flip image vertically @@ -447,6 +447,7 @@ void Window::screenshot(float zoom) { stbi_write_png(filename.c_str(), width, height, 4, data, width * 4); // Cleanup + delete[] data; nvgluBindFramebuffer(NULL); delete fb; } From c4780b4aeab261779bc17fa57c5954544a1a89a6 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 9 May 2019 00:08:51 -0400 Subject: [PATCH 11/41] Overhaul helper.py script. Change command arguments. --- helper.py | 213 +++++++++++++++++++++++++++--------------------------- 1 file changed, 107 insertions(+), 106 deletions(-) diff --git a/helper.py b/helper.py index c03b4c7d..0dae63e5 100755 --- a/helper.py +++ b/helper.py @@ -39,33 +39,15 @@ def slug_to_identifier(slug): return slug -def usage(script): - text = f"""Usage: {script} ... -Run commands without arguments for command help. - -Commands: - createplugin - createmodule - createmanifest -""" - print(text) - - -def usage_create_plugin(script): - text = f"""Usage: {script} createplugin - -A directory will be created in the current working directory and seeded with initial files. -""" - print(text) - - -def create_plugin(slug): +def create_plugin(slug, plugin_dir=None): # Check slug if not is_valid_slug(slug): raise UserException("Slug must only contain ASCII letters, numbers, '-', and '_'.") + if not plugin_dir: + plugin_dir = os.path.join(slug, '') + # Check if plugin directory exists - plugin_dir = os.path.join(slug, '') if os.path.exists(plugin_dir): raise UserException(f"Directory {plugin_dir} already exists") @@ -74,7 +56,7 @@ def create_plugin(slug): # Create manifest try: - create_manifest(plugin_dir, slug) + create_manifest(slug, plugin_dir) except Exception as e: os.rmdir(plugin_dir) raise e @@ -120,6 +102,7 @@ using namespace rack; extern Plugin *pluginInstance; // Declare each Model, defined in each module source file +// extern Model *modelMyModule; """ with open(os.path.join(plugin_dir, "src/plugin.hpp"), "w") as f: f.write(plugin_hpp) @@ -159,58 +142,57 @@ void init(Plugin *p) { print(f"You may use `make`, `make clean`, `make dist`, `make install`, etc in the {plugin_dir} directory.") -def create_manifest(plugin_dir, slug=None): - manifest = {} +def create_manifest(slug, plugin_dir="."): + # Default manifest + manifest = { + 'slug': slug, + } + + # Try to load existing manifest file + manifest_filename = os.path.join(plugin_dir, 'plugin.json') + try: + with open(manifest_filename, "r") as f: + manifest = json.load(f) + except: + pass # Query manifest information - if not slug: - slug = input_default("Plugin slug (unique identifier)") - manifest['slug'] = slug - manifest['name'] = input_default("Plugin name", slug) - manifest['version'] = input_default("Version", "1.0.0") - manifest['license'] = input_default("License (if open-source, use license identifier from https://spdx.org/licenses/)", "proprietary") - manifest['author'] = input_default("Author") - manifest['authorEmail'] = input_default("Author email (optional)") - manifest['authorUrl'] = input_default("Author website URL (optional)") - manifest['pluginUrl'] = input_default("Plugin website URL (optional)") - manifest['manualUrl'] = input_default("Manual website URL (optional)") - manifest['sourceUrl'] = input_default("Source code URL (optional)") - manifest['donateUrl'] = input_default("Donate URL (optional)") - manifest['modules'] = [] + manifest['name'] = input_default("Plugin name", manifest.get('name', slug)) + manifest['version'] = input_default("Version", manifest.get('version', "1.0.0")) + manifest['license'] = input_default("License (if open-source, use license identifier from https://spdx.org/licenses/)", manifest.get('license', "proprietary")) + manifest['author'] = input_default("Author", manifest.get('author', "")) + manifest['authorEmail'] = input_default("Author email (optional)", manifest.get('authorEmail', "")) + manifest['authorUrl'] = input_default("Author website URL (optional)", manifest.get('authorUrl', "")) + manifest['pluginUrl'] = input_default("Plugin website URL (optional)", manifest.get('pluginUrl', "")) + manifest['manualUrl'] = input_default("Manual website URL (optional)", manifest.get('manualUrl', "")) + manifest['sourceUrl'] = input_default("Source code URL (optional)", manifest.get('sourceUrl', "")) + manifest['donateUrl'] = input_default("Donate URL (optional)", manifest.get('donateUrl', "")) + + if 'modules' not in manifest: + manifest['modules'] = [] # Dump JSON - manifest_filename = os.path.join(plugin_dir, 'plugin.json') with open(manifest_filename, "w") as f: - json.dump(manifest, f, indent="\t") - print(f"Manifest created at {manifest_filename}") - - -def usage_create_module(script): - text = f"""Usage: {script} createmodule + json.dump(manifest, f, indent=" ") + print(f"Manifest written to {manifest_filename}") -Must be called in a plugin directory. -A panel file must exist in res/.svg. -A source file will be created at src/.cpp. -See https://vcvrack.com/manual/PanelTutorial.html for creating SVG panel files. -""" - print(text) - - -def create_module(slug): +def create_module(slug, panel_filename=None, source_filename=None): # Check slug if not is_valid_slug(slug): raise UserException("Slug must only contain ASCII letters, numbers, '-', and '_'.") # Read manifest manifest_filename = 'plugin.json' - manifest = None with open(manifest_filename, "r") as f: manifest = json.load(f) # Check if module manifest exists module_manifest = find(lambda m: m['slug'] == slug, manifest['modules']) - if not module_manifest: + if module_manifest: + print(f"Module {slug} already exists in plugin.json. Edit this file to modify the module manifest.") + + else: # Add module to manifest module_manifest = {} module_manifest['slug'] = slug @@ -227,50 +209,44 @@ def create_module(slug): # Write manifest with open(manifest_filename, "w") as f: - json.dump(manifest, f, indent="\t") + json.dump(manifest, f, indent=" ") print(f"Added {slug} to plugin.json") - else: - print(f"Module {slug} already exists in plugin.json. Edit this file to modify the module manifest.") - # Check filenames - panel_filename = f"res/{slug}.svg" - source_filename = f"src/{slug}.cpp" + if panel_filename and source_filename: + if not os.path.exists(panel_filename): + raise UserException(f"Panel not found at {panel_filename}.") - if not os.path.exists(panel_filename): - print(f"Panel not found at {panel_filename}. If you wish to automatically generate a source file, run this command with no arguments for instructions for creating a panel file.") - return - - print(f"Panel found at {panel_filename}. Generating source file.") + print(f"Panel found at {panel_filename}. Generating source file.") - if os.path.exists(source_filename): - if input_default(f"{source_filename} already exists. Overwrite?", "n").lower() != "y": - return + if os.path.exists(source_filename): + if input_default(f"{source_filename} already exists. Overwrite?", "n").lower() != "y": + return - # Read SVG XML - tree = xml.etree.ElementTree.parse(panel_filename) + # Read SVG XML + tree = xml.etree.ElementTree.parse(panel_filename) - components = panel_to_components(tree) - print(f"Components extracted from {panel_filename}") + components = panel_to_components(tree) + print(f"Components extracted from {panel_filename}") - # Write source - source = components_to_source(components, slug) + # Write source + source = components_to_source(components, slug) - with open(source_filename, "w") as f: - f.write(source) - print(f"Source file generated at {source_filename}") + with open(source_filename, "w") as f: + f.write(source) + print(f"Source file generated at {source_filename}") - # Append model to plugin.hpp - identifier = slug_to_identifier(slug) + # Append model to plugin.hpp + identifier = slug_to_identifier(slug) - # Tell user to add model to plugin.hpp and plugin.cpp - print(f"") - print(f"To enable the module, add") - print(f"extern Model *model{identifier};") - print(f"to plugin.hpp, and add") - print(f"p->addModel(model{identifier});") - print(f"to the init() function in plugin.cpp.") + # Tell user to add model to plugin.hpp and plugin.cpp + print(f""" +To enable the module, add +extern Model *model{identifier}; +to plugin.hpp, and add +p->addModel(model{identifier}); +to the init() function in plugin.cpp.""") def panel_to_components(tree): @@ -498,24 +474,49 @@ Model *model{identifier} = createModel<{identifier}, {identifier}Widget>("{slug} return source +def usage(script): + text = f"""VCV Rack Plugin Helper Utility + +Usage: {script} ... +Commands: + +createplugin [plugin dir] + + A directory will be created and initialized with a minimal plugin template. + If no plugin directory is given, the slug is used. + +createmanifest [plugin dir] + + Creates a `plugin.json` manifest file in an existing plugin directory. + If no plugin directory is given, the current directory is used. + +createmodule [panel file] [source file] + + Adds a new module to the plugin manifest in the current directory. + If a panel and source file are given, generates a template source file initialized with components from a panel file. + Example: + {script} createmodule MyModule res/MyModule.svg src/MyModule.cpp + + See https://vcvrack.com/manual/PanelTutorial.html for creating SVG panel files. +""" + print(text) + + def parse_args(args): - if len(args) >= 2: - if args[1] == 'createplugin': - if len(args) >= 3: - create_plugin(args[2]) - return - usage_create_plugin(args[0]) - return - if args[1] == 'createmodule': - if len(args) >= 3: - create_module(args[2]) - return - usage_create_module(args[0]) - return - if args[1] == 'createmanifest': - create_manifest('.') - return - usage(args[0]) + script = args.pop(0) + if len(args) == 0: + usage(script) + return + + cmd = args.pop(0) + if cmd == 'createplugin': + create_plugin(*args) + elif cmd == 'createmodule': + create_module(*args) + elif cmd == 'createmanifest': + create_manifest(*args) + else: + print(f"Command not found: {cmd}") if __name__ == "__main__": From 3b5380d28c33412c8944d1fec6912d0a7fc4305e Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 9 May 2019 00:28:35 -0400 Subject: [PATCH 12/41] Added Core AUDIO-16 --- res/Core/AudioInterface16.svg | 852 ++++++++++++++++++++++++++++++++++ src/Core/AudioInterface.cpp | 140 ++++-- src/Core/plugin.cpp | 7 +- src/Core/plugin.hpp | 1 + src/app/AudioWidget.cpp | 40 +- 5 files changed, 982 insertions(+), 58 deletions(-) create mode 100644 res/Core/AudioInterface16.svg diff --git a/res/Core/AudioInterface16.svg b/res/Core/AudioInterface16.svg new file mode 100644 index 00000000..f44cb9e2 --- /dev/null +++ b/res/Core/AudioInterface16.svg @@ -0,0 +1,852 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/Core/AudioInterface.cpp b/src/Core/AudioInterface.cpp index 9774b127..dcb3f879 100644 --- a/src/Core/AudioInterface.cpp +++ b/src/Core/AudioInterface.cpp @@ -8,13 +8,10 @@ #include -static const int AUDIO_OUTPUTS = 8; -static const int AUDIO_INPUTS = 8; - - using namespace rack; +template struct AudioInterfacePort : audio::Port { std::mutex engineMutex; std::condition_variable engineCv; @@ -87,6 +84,7 @@ struct AudioInterfacePort : audio::Port { }; +template struct AudioInterface : Module { enum ParamIds { NUM_PARAMS @@ -105,7 +103,7 @@ struct AudioInterface : Module { NUM_LIGHTS }; - AudioInterfacePort port; + AudioInterfacePort port; int lastSampleRate = 0; int lastNumOutputs = -1; int lastNumInputs = -1; @@ -232,8 +230,10 @@ struct AudioInterface : Module { }; -struct AudioInterfaceWidget : ModuleWidget { - AudioInterfaceWidget(AudioInterface *module) { +struct AudioInterface8Widget : ModuleWidget { + typedef AudioInterface<8, 8> TAudioInterface; + + AudioInterface8Widget(TAudioInterface *module) { setModule(module); setPanel(APP->window->loadSvg(asset::system("res/Core/AudioInterface.svg"))); @@ -242,32 +242,32 @@ struct AudioInterfaceWidget : ModuleWidget { addChild(createWidget(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH))); addChild(createWidget(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH))); - addInput(createInput(mm2px(Vec(3.7069211, 55.530807)), module, AudioInterface::AUDIO_INPUT + 0)); - addInput(createInput(mm2px(Vec(15.307249, 55.530807)), module, AudioInterface::AUDIO_INPUT + 1)); - addInput(createInput(mm2px(Vec(26.906193, 55.530807)), module, AudioInterface::AUDIO_INPUT + 2)); - addInput(createInput(mm2px(Vec(38.506519, 55.530807)), module, AudioInterface::AUDIO_INPUT + 3)); - addInput(createInput(mm2px(Vec(3.7069209, 70.144905)), module, AudioInterface::AUDIO_INPUT + 4)); - addInput(createInput(mm2px(Vec(15.307249, 70.144905)), module, AudioInterface::AUDIO_INPUT + 5)); - addInput(createInput(mm2px(Vec(26.906193, 70.144905)), module, AudioInterface::AUDIO_INPUT + 6)); - addInput(createInput(mm2px(Vec(38.506519, 70.144905)), module, AudioInterface::AUDIO_INPUT + 7)); - - addOutput(createOutput(mm2px(Vec(3.7069209, 92.143906)), module, AudioInterface::AUDIO_OUTPUT + 0)); - addOutput(createOutput(mm2px(Vec(15.307249, 92.143906)), module, AudioInterface::AUDIO_OUTPUT + 1)); - addOutput(createOutput(mm2px(Vec(26.906193, 92.143906)), module, AudioInterface::AUDIO_OUTPUT + 2)); - addOutput(createOutput(mm2px(Vec(38.506519, 92.143906)), module, AudioInterface::AUDIO_OUTPUT + 3)); - addOutput(createOutput(mm2px(Vec(3.7069209, 108.1443)), module, AudioInterface::AUDIO_OUTPUT + 4)); - addOutput(createOutput(mm2px(Vec(15.307249, 108.1443)), module, AudioInterface::AUDIO_OUTPUT + 5)); - addOutput(createOutput(mm2px(Vec(26.906193, 108.1443)), module, AudioInterface::AUDIO_OUTPUT + 6)); - addOutput(createOutput(mm2px(Vec(38.506523, 108.1443)), module, AudioInterface::AUDIO_OUTPUT + 7)); - - addChild(createLight>(mm2px(Vec(12.524985, 54.577202)), module, AudioInterface::INPUT_LIGHT + 0)); - addChild(createLight>(mm2px(Vec(35.725647, 54.577202)), module, AudioInterface::INPUT_LIGHT + 1)); - addChild(createLight>(mm2px(Vec(12.524985, 69.158226)), module, AudioInterface::INPUT_LIGHT + 2)); - addChild(createLight>(mm2px(Vec(35.725647, 69.158226)), module, AudioInterface::INPUT_LIGHT + 3)); - addChild(createLight>(mm2px(Vec(12.524985, 91.147583)), module, AudioInterface::OUTPUT_LIGHT + 0)); - addChild(createLight>(mm2px(Vec(35.725647, 91.147583)), module, AudioInterface::OUTPUT_LIGHT + 1)); - addChild(createLight>(mm2px(Vec(12.524985, 107.17003)), module, AudioInterface::OUTPUT_LIGHT + 2)); - addChild(createLight>(mm2px(Vec(35.725647, 107.17003)), module, AudioInterface::OUTPUT_LIGHT + 3)); + addInput(createInput(mm2px(Vec(3.7069211, 55.530807)), module, TAudioInterface::AUDIO_INPUT + 0)); + addInput(createInput(mm2px(Vec(15.307249, 55.530807)), module, TAudioInterface::AUDIO_INPUT + 1)); + addInput(createInput(mm2px(Vec(26.906193, 55.530807)), module, TAudioInterface::AUDIO_INPUT + 2)); + addInput(createInput(mm2px(Vec(38.506519, 55.530807)), module, TAudioInterface::AUDIO_INPUT + 3)); + addInput(createInput(mm2px(Vec(3.7069209, 70.144905)), module, TAudioInterface::AUDIO_INPUT + 4)); + addInput(createInput(mm2px(Vec(15.307249, 70.144905)), module, TAudioInterface::AUDIO_INPUT + 5)); + addInput(createInput(mm2px(Vec(26.906193, 70.144905)), module, TAudioInterface::AUDIO_INPUT + 6)); + addInput(createInput(mm2px(Vec(38.506519, 70.144905)), module, TAudioInterface::AUDIO_INPUT + 7)); + + addOutput(createOutput(mm2px(Vec(3.7069209, 92.143906)), module, TAudioInterface::AUDIO_OUTPUT + 0)); + addOutput(createOutput(mm2px(Vec(15.307249, 92.143906)), module, TAudioInterface::AUDIO_OUTPUT + 1)); + addOutput(createOutput(mm2px(Vec(26.906193, 92.143906)), module, TAudioInterface::AUDIO_OUTPUT + 2)); + addOutput(createOutput(mm2px(Vec(38.506519, 92.143906)), module, TAudioInterface::AUDIO_OUTPUT + 3)); + addOutput(createOutput(mm2px(Vec(3.7069209, 108.1443)), module, TAudioInterface::AUDIO_OUTPUT + 4)); + addOutput(createOutput(mm2px(Vec(15.307249, 108.1443)), module, TAudioInterface::AUDIO_OUTPUT + 5)); + addOutput(createOutput(mm2px(Vec(26.906193, 108.1443)), module, TAudioInterface::AUDIO_OUTPUT + 6)); + addOutput(createOutput(mm2px(Vec(38.506523, 108.1443)), module, TAudioInterface::AUDIO_OUTPUT + 7)); + + addChild(createLight>(mm2px(Vec(12.524985, 54.577202)), module, TAudioInterface::INPUT_LIGHT + 0)); + addChild(createLight>(mm2px(Vec(35.725647, 54.577202)), module, TAudioInterface::INPUT_LIGHT + 1)); + addChild(createLight>(mm2px(Vec(12.524985, 69.158226)), module, TAudioInterface::INPUT_LIGHT + 2)); + addChild(createLight>(mm2px(Vec(35.725647, 69.158226)), module, TAudioInterface::INPUT_LIGHT + 3)); + addChild(createLight>(mm2px(Vec(12.524985, 91.147583)), module, TAudioInterface::OUTPUT_LIGHT + 0)); + addChild(createLight>(mm2px(Vec(35.725647, 91.147583)), module, TAudioInterface::OUTPUT_LIGHT + 1)); + addChild(createLight>(mm2px(Vec(12.524985, 107.17003)), module, TAudioInterface::OUTPUT_LIGHT + 2)); + addChild(createLight>(mm2px(Vec(35.725647, 107.17003)), module, TAudioInterface::OUTPUT_LIGHT + 3)); AudioWidget *audioWidget = createWidget(mm2px(Vec(3.2122073, 14.837339))); audioWidget->box.size = mm2px(Vec(44, 28)); @@ -277,4 +277,76 @@ struct AudioInterfaceWidget : ModuleWidget { }; -Model *modelAudioInterface = createModel("AudioInterface"); \ No newline at end of file +struct AudioInterface16Widget : ModuleWidget { + typedef AudioInterface<16, 16> TAudioInterface; + + AudioInterface16Widget(TAudioInterface *module) { + setModule(module); + setPanel(APP->window->loadSvg(asset::system("res/Core/AudioInterface16.svg"))); + + addChild(createWidget(Vec(RACK_GRID_WIDTH, 0))); + addChild(createWidget(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0))); + addChild(createWidget(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH))); + addChild(createWidget(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH))); + + addInput(createInputCentered(mm2px(Vec(7.661, 59.638)), module, TAudioInterface::AUDIO_INPUT + 0)); + addInput(createInputCentered(mm2px(Vec(19.26, 59.638)), module, TAudioInterface::AUDIO_INPUT + 1)); + addInput(createInputCentered(mm2px(Vec(30.86, 59.638)), module, TAudioInterface::AUDIO_INPUT + 2)); + addInput(createInputCentered(mm2px(Vec(42.461, 59.638)), module, TAudioInterface::AUDIO_INPUT + 3)); + addInput(createInputCentered(mm2px(Vec(54.06, 59.638)), module, TAudioInterface::AUDIO_INPUT + 4)); + addInput(createInputCentered(mm2px(Vec(65.661, 59.638)), module, TAudioInterface::AUDIO_INPUT + 5)); + addInput(createInputCentered(mm2px(Vec(77.26, 59.638)), module, TAudioInterface::AUDIO_INPUT + 6)); + addInput(createInputCentered(mm2px(Vec(88.86, 59.638)), module, TAudioInterface::AUDIO_INPUT + 7)); + addInput(createInputCentered(mm2px(Vec(7.661, 74.251)), module, TAudioInterface::AUDIO_INPUT + 8)); + addInput(createInputCentered(mm2px(Vec(19.26, 74.251)), module, TAudioInterface::AUDIO_INPUT + 9)); + addInput(createInputCentered(mm2px(Vec(30.86, 74.251)), module, TAudioInterface::AUDIO_INPUT + 10)); + addInput(createInputCentered(mm2px(Vec(42.461, 74.251)), module, TAudioInterface::AUDIO_INPUT + 11)); + addInput(createInputCentered(mm2px(Vec(54.06, 74.251)), module, TAudioInterface::AUDIO_INPUT + 12)); + addInput(createInputCentered(mm2px(Vec(65.661, 74.251)), module, TAudioInterface::AUDIO_INPUT + 13)); + addInput(createInputCentered(mm2px(Vec(77.26, 74.251)), module, TAudioInterface::AUDIO_INPUT + 14)); + addInput(createInputCentered(mm2px(Vec(88.86, 74.251)), module, TAudioInterface::AUDIO_INPUT + 15)); + + addOutput(createOutputCentered(mm2px(Vec(7.661, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 0)); + addOutput(createOutputCentered(mm2px(Vec(19.26, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 1)); + addOutput(createOutputCentered(mm2px(Vec(30.86, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 2)); + addOutput(createOutputCentered(mm2px(Vec(42.461, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 3)); + addOutput(createOutputCentered(mm2px(Vec(54.06, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 4)); + addOutput(createOutputCentered(mm2px(Vec(65.661, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 5)); + addOutput(createOutputCentered(mm2px(Vec(77.26, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 6)); + addOutput(createOutputCentered(mm2px(Vec(88.86, 96.251)), module, TAudioInterface::AUDIO_OUTPUT + 7)); + addOutput(createOutputCentered(mm2px(Vec(7.661, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 8)); + addOutput(createOutputCentered(mm2px(Vec(19.26, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 9)); + addOutput(createOutputCentered(mm2px(Vec(30.86, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 10)); + addOutput(createOutputCentered(mm2px(Vec(42.461, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 11)); + addOutput(createOutputCentered(mm2px(Vec(54.06, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 12)); + addOutput(createOutputCentered(mm2px(Vec(65.661, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 13)); + addOutput(createOutputCentered(mm2px(Vec(77.26, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 14)); + addOutput(createOutputCentered(mm2px(Vec(88.86, 112.252)), module, TAudioInterface::AUDIO_OUTPUT + 15)); + + addChild(createLightCentered>(mm2px(Vec(13.46, 55.667)), module, TAudioInterface::INPUT_LIGHT + 0)); + addChild(createLightCentered>(mm2px(Vec(36.661, 55.667)), module, TAudioInterface::INPUT_LIGHT + 1)); + addChild(createLightCentered>(mm2px(Vec(59.861, 55.667)), module, TAudioInterface::INPUT_LIGHT + 2)); + addChild(createLightCentered>(mm2px(Vec(83.061, 55.667)), module, TAudioInterface::INPUT_LIGHT + 3)); + addChild(createLightCentered>(mm2px(Vec(13.46, 70.248)), module, TAudioInterface::INPUT_LIGHT + 4)); + addChild(createLightCentered>(mm2px(Vec(36.661, 70.248)), module, TAudioInterface::INPUT_LIGHT + 5)); + addChild(createLightCentered>(mm2px(Vec(59.861, 70.248)), module, TAudioInterface::INPUT_LIGHT + 6)); + addChild(createLightCentered>(mm2px(Vec(83.061, 70.248)), module, TAudioInterface::INPUT_LIGHT + 7)); + addChild(createLightCentered>(mm2px(Vec(13.46, 92.238)), module, TAudioInterface::OUTPUT_LIGHT + 0)); + addChild(createLightCentered>(mm2px(Vec(36.661, 92.238)), module, TAudioInterface::OUTPUT_LIGHT + 1)); + addChild(createLightCentered>(mm2px(Vec(59.861, 92.238)), module, TAudioInterface::OUTPUT_LIGHT + 2)); + addChild(createLightCentered>(mm2px(Vec(83.061, 92.238)), module, TAudioInterface::OUTPUT_LIGHT + 3)); + addChild(createLightCentered>(mm2px(Vec(13.46, 108.259)), module, TAudioInterface::OUTPUT_LIGHT + 4)); + addChild(createLightCentered>(mm2px(Vec(36.661, 108.259)), module, TAudioInterface::OUTPUT_LIGHT + 5)); + addChild(createLightCentered>(mm2px(Vec(59.861, 108.259)), module, TAudioInterface::OUTPUT_LIGHT + 6)); + addChild(createLightCentered>(mm2px(Vec(83.061, 108.259)), module, TAudioInterface::OUTPUT_LIGHT + 7)); + + AudioWidget *audioWidget = createWidget(mm2px(Vec(2.57, 14.839))); + audioWidget->box.size = mm2px(Vec(91.382, 28.0)); + audioWidget->setAudioPort(module ? &module->port : NULL); + addChild(audioWidget); + } +}; + + +Model *modelAudioInterface = createModel, AudioInterface8Widget>("AudioInterface"); +Model *modelAudioInterface16 = createModel, AudioInterface16Widget>("AudioInterface16"); diff --git a/src/Core/plugin.cpp b/src/Core/plugin.cpp index d0851646..2e93c0cd 100644 --- a/src/Core/plugin.cpp +++ b/src/Core/plugin.cpp @@ -13,11 +13,16 @@ void init(rack::Plugin *p) { p->manualUrl = "https://vcvrack.com/manual/Core.html"; p->sourceUrl = "https://github.com/VCVRack/Rack"; - modelAudioInterface->name = "Audio"; + modelAudioInterface->name = "Audio 8"; modelAudioInterface->description = "Sends audio and CV to/from an audio device"; modelAudioInterface->tags = {"External"}; p->addModel(modelAudioInterface); + modelAudioInterface16->name = "Audio 16"; + modelAudioInterface16->description = "Sends audio and CV to/from an audio device"; + modelAudioInterface16->tags = {"External"}; + p->addModel(modelAudioInterface16); + modelMIDI_CV->name = "MIDI-CV"; modelMIDI_CV->description = "Converts MIDI from an external device to CV and gates"; modelMIDI_CV->tags = {"External", "MIDI"}; diff --git a/src/Core/plugin.hpp b/src/Core/plugin.hpp index 3062f193..6e5128c2 100644 --- a/src/Core/plugin.hpp +++ b/src/Core/plugin.hpp @@ -5,6 +5,7 @@ using namespace rack; extern Model *modelAudioInterface; +extern Model *modelAudioInterface16; extern Model *modelMIDI_CV; extern Model *modelMIDI_CC; extern Model *modelMIDI_Gate; diff --git a/src/app/AudioWidget.cpp b/src/app/AudioWidget.cpp index a423ea0a..4b0679f9 100644 --- a/src/app/AudioWidget.cpp +++ b/src/app/AudioWidget.cpp @@ -33,10 +33,10 @@ struct AudioDriverChoice : LedDisplayChoice { } } void step() override { - if (port) - text = port->getDriverName(port->driverId); - else - text = "Audio driver"; + text = (!port || box.size.x >= 200.0) ? "Driver: " : ""; + if (port) { + text += port->getDriverName(port->driverId); + } } }; @@ -84,17 +84,11 @@ struct AudioDeviceChoice : LedDisplayChoice { } } void step() override { - if (!port) { - text = "Audio device"; - return; - } - text = port->getDeviceDetail(port->deviceId, port->offset); - if (text.empty()) { - text = "(No device)"; - color.a = 0.5f; - } - else { - color.a = 1.f; + text = (!port || box.size.x >= 200.0) ? "Device: " : ""; + if (port) { + std::string detail = port->getDeviceDetail(port->deviceId, port->offset); + text += detail; + color.a = (detail == "") ? 0.5f : 1.f; } } }; @@ -130,10 +124,10 @@ struct AudioSampleRateChoice : LedDisplayChoice { } } void step() override { - if (port) - text = string::f("%g kHz", port->sampleRate / 1000.0); - else - text = "44.1 kHz"; + text = (!port || box.size.x >= 100.0) ? "Rate: " : ""; + if (port) { + text += string::f("%g kHz", port->sampleRate / 1000.0); + } } }; @@ -169,10 +163,10 @@ struct AudioBlockSizeChoice : LedDisplayChoice { } } void step() override { - if (port) - text = string::f("%d", port->blockSize); - else - text = "256"; + text = (!port || box.size.x >= 100.0) ? "Block size: " : ""; + if (port) { + text += string::f("%d", port->blockSize); + } } }; From e4db0bf8925dea41736a1cef2cf5597eaf7408f3 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 9 May 2019 16:39:31 -0400 Subject: [PATCH 13/41] Clean up AudioWidget/MidiWidget default state. Re-enable JACK in RtAudio dep. --- Makefile | 3 ++- dep/Makefile | 2 +- src/app/AudioWidget.cpp | 32 ++++++++++++++++++++++++-------- src/app/MidiWidget.cpp | 17 +++-------------- 4 files changed, 30 insertions(+), 24 deletions(-) diff --git a/Makefile b/Makefile index 3bf6d7db..1780121e 100644 --- a/Makefile +++ b/Makefile @@ -18,7 +18,8 @@ SOURCES += $(wildcard src/*.cpp src/*/*.cpp) ifdef ARCH_LIN SOURCES += dep/osdialog/osdialog_gtk2.c - CFLAGS += $(shell pkg-config --cflags gtk+-2.0) +build/dep/osdialog/osdialog_gtk2.c.o: FLAGS += $(shell pkg-config --cflags gtk+-2.0) + LDFLAGS += -rdynamic \ dep/lib/libglfw3.a dep/lib/libGLEW.a dep/lib/libjansson.a dep/lib/libspeexdsp.a dep/lib/libzip.a dep/lib/libz.a dep/lib/librtmidi.a dep/lib/librtaudio.a dep/lib/libcurl.a dep/lib/libssl.a dep/lib/libcrypto.a \ -lpthread -lGL -ldl -lX11 -lasound -ljack \ diff --git a/dep/Makefile b/dep/Makefile index 5f0cd941..3c7a4208 100755 --- a/dep/Makefile +++ b/dep/Makefile @@ -151,7 +151,7 @@ ifdef ARCH_WIN RTAUDIO_FLAGS += -DRTAUDIO_API_DS=ON -DRTAUDIO_API_WASAPI=ON -DRTAUDIO_API_ASIO=ON endif ifdef ARCH_LIN -RTAUDIO_FLAGS += -DRTAUDIO_API_ALSA=ON -DRTAUDIO_API_JACK=OFF -DRTAUDIO_API_PULSE=OFF -DRTAUDIO_API_OSS=OFF +RTAUDIO_FLAGS += -DRTAUDIO_API_ALSA=ON -DRTAUDIO_API_JACK=ON -DRTAUDIO_API_PULSE=OFF -DRTAUDIO_API_OSS=OFF endif $(rtaudio): diff --git a/src/app/AudioWidget.cpp b/src/app/AudioWidget.cpp index 4b0679f9..e0994f75 100644 --- a/src/app/AudioWidget.cpp +++ b/src/app/AudioWidget.cpp @@ -33,9 +33,15 @@ struct AudioDriverChoice : LedDisplayChoice { } } void step() override { - text = (!port || box.size.x >= 200.0) ? "Driver: " : ""; - if (port) { - text += port->getDriverName(port->driverId); + text = (box.size.x >= 200.0) ? "Driver: " : ""; + std::string driverName = (port) ? port->getDriverName(port->driverId) : ""; + if (driverName != "") { + text += driverName; + color.a = 1.f; + } + else { + text += "(No driver)"; + color.a = 0.5f; } } }; @@ -84,12 +90,16 @@ struct AudioDeviceChoice : LedDisplayChoice { } } void step() override { - text = (!port || box.size.x >= 200.0) ? "Device: " : ""; - if (port) { - std::string detail = port->getDeviceDetail(port->deviceId, port->offset); + text = (box.size.x >= 200.0) ? "Device: " : ""; + std::string detail = (port) ? port->getDeviceDetail(port->deviceId, port->offset) : ""; + if (detail != "") { text += detail; color.a = (detail == "") ? 0.5f : 1.f; } + else { + text += "(No device)"; + color.a = 0.5f; + } } }; @@ -124,10 +134,13 @@ struct AudioSampleRateChoice : LedDisplayChoice { } } void step() override { - text = (!port || box.size.x >= 100.0) ? "Rate: " : ""; + text = (box.size.x >= 100.0) ? "Rate: " : ""; if (port) { text += string::f("%g kHz", port->sampleRate / 1000.0); } + else { + text += "0 kHz"; + } } }; @@ -163,10 +176,13 @@ struct AudioBlockSizeChoice : LedDisplayChoice { } } void step() override { - text = (!port || box.size.x >= 100.0) ? "Block size: " : ""; + text = (box.size.x >= 100.0) ? "Block size: " : ""; if (port) { text += string::f("%d", port->blockSize); } + else { + text += "0"; + } } }; diff --git a/src/app/MidiWidget.cpp b/src/app/MidiWidget.cpp index f30d455d..02d93b23 100644 --- a/src/app/MidiWidget.cpp +++ b/src/app/MidiWidget.cpp @@ -33,11 +33,7 @@ struct MidiDriverChoice : LedDisplayChoice { } } void step() override { - if (!port) { - text = "MIDI driver"; - return; - } - text = port->getDriverName(port->driverId); + text = port ? port->getDriverName(port->driverId) : ""; if (text.empty()) { text = "(No driver)"; color.a = 0.5f; @@ -82,11 +78,7 @@ struct MidiDeviceChoice : LedDisplayChoice { } } void step() override { - if (!port) { - text = "MIDI device"; - return; - } - text = port->getDeviceName(port->deviceId); + text = port ? port->getDeviceName(port->deviceId) : ""; if (text.empty()) { text = "(No device)"; color.a = 0.5f; @@ -123,10 +115,7 @@ struct MidiChannelChoice : LedDisplayChoice { } } void step() override { - if (port) - text = port->getChannelName(port->channel); - else - text = "MIDI channel"; + text = port ? port->getChannelName(port->channel) : "Channel 1"; } }; From e92b9d033974ff3267decfba377fac0da42ca541 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 9 May 2019 16:59:14 -0400 Subject: [PATCH 14/41] Save temporary patch file and rename it over desired patch. --- src/app/RackScrollWidget.cpp | 2 +- src/patch.cpp | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/app/RackScrollWidget.cpp b/src/app/RackScrollWidget.cpp index 63728a71..cc7808cd 100644 --- a/src/app/RackScrollWidget.cpp +++ b/src/app/RackScrollWidget.cpp @@ -43,7 +43,7 @@ void RackScrollWidget::step() { math::Rect scrollBox = moduleBox; scrollBox.pos = scrollBox.pos.mult(zoom); scrollBox.size = scrollBox.size.mult(zoom); - scrollBox = scrollBox.grow(box.size.div(2)); + scrollBox = scrollBox.grow(box.size.mult(0.6666)); // Expand to the current viewport box so that moving modules (and thus changing the module bounding box) doesn't clamp the scroll offset. math::Rect viewportBox; diff --git a/src/patch.cpp b/src/patch.cpp index f6cc9b81..fc0eda6a 100644 --- a/src/patch.cpp +++ b/src/patch.cpp @@ -81,16 +81,17 @@ void PatchManager::save(std::string path) { json_decref(rootJ); }); - FILE *file = std::fopen(path.c_str(), "w"); + // Write to temporary path and then rename it to the correct path + std::string tmpPath = path + ".tmp"; + FILE *file = std::fopen(tmpPath.c_str(), "w"); if (!file) { // Fail silently return; } - DEFER({ - std::fclose(file); - }); json_dumpf(rootJ, file, JSON_INDENT(2) | JSON_REAL_PRECISION(9)); + std::fclose(file); + std::rename(tmpPath.c_str(), path.c_str()); } void PatchManager::saveDialog() { From 30c5b24ec5e77306a0737ba361aefe351eaa26b1 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 10 May 2019 05:41:49 -0400 Subject: [PATCH 15/41] Add Engine::yieldWorker() which turns worker spinlocks into mutex locks. Fix race condition in EngineWorker::run() when changing number of threads. --- CHANGELOG.md | 3 ++ include/engine/Engine.hpp | 4 +++ src/Core/AudioInterface.cpp | 2 ++ src/app/Scene.cpp | 2 +- src/engine/Engine.cpp | 70 ++++++++++++++++++++++++++++++------- 5 files changed, 67 insertions(+), 14 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 662dba2b..981dc002 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,8 @@ - Fix draw order of cable plugs and wires - Make Gamepad MIDI driver generate MIDI CC instead of MIDI notes for buttons - Fix Unicode user directories on Windows +- Add ability to change cable colors in `settings.json` +- Add `-p X` flag for dumping a screenshot of each available module - Core - Add Core CV-MIDI, CV-CC, and CV-Gate for sending MIDI to external devices @@ -35,6 +37,7 @@ - Add polyphony to Core MIDI-CV - Add MPE mode to Core MIDI-CV - Add "Panic" button to all MIDI modules to reset performance state + - Add Core Audio 16 - API - Add [`simd.hpp`](include/dsp/simd.hpp) for generically handling arithmetic and math functions for vectors of floats, accelerated with SSE diff --git a/include/engine/Engine.hpp b/include/engine/Engine.hpp index 0f293f58..b15bc036 100644 --- a/include/engine/Engine.hpp +++ b/include/engine/Engine.hpp @@ -25,6 +25,10 @@ struct Engine { float getSampleRate(); /** Returns the inverse of the current sample rate. */ float getSampleTime(); + /** Causes worker threads to block on a mutex instead of spinlock. + Call this in your Module::step() method to hint that the operation will take more than ~0.1 ms. + */ + void yieldWorkers(); // Modules /** Adds a module to the rack engine. diff --git a/src/Core/AudioInterface.cpp b/src/Core/AudioInterface.cpp index dcb3f879..093ed7a3 100644 --- a/src/Core/AudioInterface.cpp +++ b/src/Core/AudioInterface.cpp @@ -132,6 +132,7 @@ struct AudioInterface : Module { if (port.active && port.numInputs > 0) { // Wait until inputs are present // Give up after a timeout in case the audio device is being unresponsive. + APP->engine->yieldWorkers(); std::unique_lock lock(port.engineMutex); auto cond = [&] { return (!port.inputBuffer.empty()); @@ -181,6 +182,7 @@ struct AudioInterface : Module { if (outputBuffer.full()) { // Wait until enough outputs are consumed // Give up after a timeout in case the audio device is being unresponsive. + APP->engine->yieldWorkers(); std::unique_lock lock(port.engineMutex); auto cond = [&] { return (port.outputBuffer.size() < (size_t) port.blockSize); diff --git a/src/app/Scene.cpp b/src/app/Scene.cpp index cee6b416..4a093253 100644 --- a/src/app/Scene.cpp +++ b/src/app/Scene.cpp @@ -148,7 +148,7 @@ void Scene::onHoverKey(const event::HoverKey &e) { case GLFW_KEY_F11: { APP->window->setFullScreen(!APP->window->isFullScreen()); e.consume(this); - } + } break; } } } diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index 61c4d058..6b14c05f 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -96,6 +96,50 @@ struct SpinBarrier { }; +/** Spinlocks until all `total` threads are waiting. +If `yield` is set to true at any time, all threads will switch to waiting on a mutex instead. +All threads must return before beginning a new phase. Alternating between two barriers solves this problem. +*/ +struct HybridBarrier { + std::atomic count {0}; + int total = 0; + + std::mutex mutex; + std::condition_variable cv; + + std::atomic yield {false}; + + void wait() { + int id = ++count; + + // End and reset phase if this is the last thread + if (id == total) { + count = 0; + if (yield) { + std::unique_lock lock(mutex); + cv.notify_all(); + yield = false; + } + return; + } + + // Spinlock + while (!yield) { + if (count == 0) + return; + } + + // Wait on mutex + { + std::unique_lock lock(mutex); + cv.wait(lock, [&]{ + return count == 0; + }); + } + } +}; + + struct EngineWorker { Engine *engine; int id; @@ -117,7 +161,6 @@ struct EngineWorker { } void run(); - void step(); }; @@ -146,8 +189,8 @@ struct Engine::Internal { bool realTime = false; int threadCount = 1; std::vector workers; - SpinBarrier engineBarrier; - SpinBarrier workerBarrier; + HybridBarrier engineBarrier; + HybridBarrier workerBarrier; std::atomic workerModuleIndex; }; @@ -417,6 +460,10 @@ float Engine::getSampleTime() { return internal->sampleTime; } +void Engine::yieldWorkers() { + internal->workerBarrier.yield = true; +} + void Engine::addModule(Module *module) { assert(module); VIPLock vipLock(internal->vipMutex); @@ -698,17 +745,14 @@ void EngineWorker::run() { system::setThreadName("Engine worker"); system::setThreadRealTime(engine->internal->realTime); disableDenormals(); - while (running) { - step(); - } -} -void EngineWorker::step() { - engine->internal->engineBarrier.wait(); - if (!running) - return; - Engine_stepModules(engine, id); - engine->internal->workerBarrier.wait(); + while (1) { + engine->internal->engineBarrier.wait(); + if (!running) + return; + Engine_stepModules(engine, id); + engine->internal->workerBarrier.wait(); + } } From 269f9aca9b19535e78502536c1bff441c76792a8 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 10 May 2019 11:01:09 -0400 Subject: [PATCH 16/41] Only use Engine::yieldWorkers() when we know it's needed in Core Audio. Use _mm_pause() in spinlocks. --- Makefile | 3 ++- include/simd/sse_mathfun.h | 2 +- include/simd/vector.hpp | 2 +- src/Core/AudioInterface.cpp | 6 +++--- src/engine/Engine.cpp | 8 +++++--- 5 files changed, 12 insertions(+), 9 deletions(-) diff --git a/Makefile b/Makefile index 1780121e..145d2bab 100644 --- a/Makefile +++ b/Makefile @@ -72,7 +72,8 @@ perf: $(TARGET) # Requires gperftools perf record --call-graph dwarf -o perf.data ./$< -d # Analyze with hotspot (https://github.com/KDAB/hotspot) for example - # hotspot perf.data + hotspot perf.data + rm perf.data valgrind: $(TARGET) # --gen-suppressions=yes diff --git a/include/simd/sse_mathfun.h b/include/simd/sse_mathfun.h index 64188187..69b74d33 100644 --- a/include/simd/sse_mathfun.h +++ b/include/simd/sse_mathfun.h @@ -45,7 +45,7 @@ This derived source file is released under the zlib license. */ -#include +#include /** Generate 1.f without accessing memory */ diff --git a/include/simd/vector.hpp b/include/simd/vector.hpp index ce1ec3ed..a043f6bf 100644 --- a/include/simd/vector.hpp +++ b/include/simd/vector.hpp @@ -1,6 +1,6 @@ #pragma once #include -#include +#include namespace rack { diff --git a/src/Core/AudioInterface.cpp b/src/Core/AudioInterface.cpp index 093ed7a3..92c5edb2 100644 --- a/src/Core/AudioInterface.cpp +++ b/src/Core/AudioInterface.cpp @@ -132,7 +132,6 @@ struct AudioInterface : Module { if (port.active && port.numInputs > 0) { // Wait until inputs are present // Give up after a timeout in case the audio device is being unresponsive. - APP->engine->yieldWorkers(); std::unique_lock lock(port.engineMutex); auto cond = [&] { return (!port.inputBuffer.empty()); @@ -182,11 +181,12 @@ struct AudioInterface : Module { if (outputBuffer.full()) { // Wait until enough outputs are consumed // Give up after a timeout in case the audio device is being unresponsive. - APP->engine->yieldWorkers(); - std::unique_lock lock(port.engineMutex); auto cond = [&] { return (port.outputBuffer.size() < (size_t) port.blockSize); }; + if (!cond()) + APP->engine->yieldWorkers(); + std::unique_lock lock(port.engineMutex); auto timeout = std::chrono::milliseconds(200); if (port.engineCv.wait_for(lock, timeout, cond)) { // Push converted output diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index 6b14c05f..4b1b6cf1 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -9,8 +9,7 @@ #include #include #include -#include -#include +#include namespace rack { @@ -90,7 +89,9 @@ struct SpinBarrier { count = 0; } else { - while (count != 0); + while (count != 0) { + _mm_pause(); + } } } }; @@ -127,6 +128,7 @@ struct HybridBarrier { while (!yield) { if (count == 0) return; + _mm_pause(); } // Wait on mutex From df0388c9fb644abe95bd8dd651e8c78e862a4d77 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 10 May 2019 13:11:15 -0400 Subject: [PATCH 17/41] Re-add METHOD_ prefix to network::Method enums --- dep/glfw | 2 +- dep/nanosvg | 2 +- dep/nanovg | 2 +- dep/rtaudio | 2 +- include/network.hpp | 8 ++++---- src/app/Scene.cpp | 2 +- src/network.cpp | 10 +++++----- src/plugin.cpp | 6 +++--- 8 files changed, 17 insertions(+), 17 deletions(-) diff --git a/dep/glfw b/dep/glfw index d9ab59ef..7ba23eb0 160000 --- a/dep/glfw +++ b/dep/glfw @@ -1 +1 @@ -Subproject commit d9ab59efc781c392128a449361a381fcc93cf6f3 +Subproject commit 7ba23eb03854dfe6ce36cc6d61cb913f76cad774 diff --git a/dep/nanosvg b/dep/nanosvg index 25241c5a..c1f6e209 160000 --- a/dep/nanosvg +++ b/dep/nanosvg @@ -1 +1 @@ -Subproject commit 25241c5a8f8451d41ab1b02ab2d865b01600d949 +Subproject commit c1f6e209c16b18b46aa9f45d7e619acf42c29726 diff --git a/dep/nanovg b/dep/nanovg index 1f9c8864..f4069e6a 160000 --- a/dep/nanovg +++ b/dep/nanovg @@ -1 +1 @@ -Subproject commit 1f9c8864fc556a1be4d4bf1d6bfe20cde25734b4 +Subproject commit f4069e6a1ad5da430fb0a9c57476d5ddc2ff89b2 diff --git a/dep/rtaudio b/dep/rtaudio index d27f257b..b9468aa6 160000 --- a/dep/rtaudio +++ b/dep/rtaudio @@ -1 +1 @@ -Subproject commit d27f257b4bc827e4152cdc4d69a2e22084204afd +Subproject commit b9468aa6f82fdea1f3dc364f477e859b39f0bb2a diff --git a/include/network.hpp b/include/network.hpp index 4fb55338..f6d9dcd8 100644 --- a/include/network.hpp +++ b/include/network.hpp @@ -12,10 +12,10 @@ namespace network { enum Method { - GET, - POST, - PUT, - DELETE, + METHOD_GET, + METHOD_POST, + METHOD_PUT, + METHOD_DELETE, }; /** Requests a JSON API URL over HTTP(S), using the data as the query (GET) or the body (POST, etc) diff --git a/src/app/Scene.cpp b/src/app/Scene.cpp index 4a093253..4ba81c25 100644 --- a/src/app/Scene.cpp +++ b/src/app/Scene.cpp @@ -170,7 +170,7 @@ void Scene::onPathDrop(const event::PathDrop &e) { void Scene::runCheckVersion() { std::string versionUrl = app::API_URL; versionUrl += "/version"; - json_t *versionResJ = network::requestJson(network::GET, versionUrl, NULL); + json_t *versionResJ = network::requestJson(network::METHOD_GET, versionUrl, NULL); if (versionResJ) { json_t *versionJ = json_object_get(versionResJ, "version"); diff --git a/src/network.cpp b/src/network.cpp index 9e4eb7a3..6a27b85e 100644 --- a/src/network.cpp +++ b/src/network.cpp @@ -24,7 +24,7 @@ json_t *requestJson(Method method, std::string url, json_t *dataJ) { // Process data if (dataJ) { - if (method == GET) { + if (method == METHOD_GET) { // Append ?key=value&... to url url += "?"; bool isFirst = true; @@ -54,16 +54,16 @@ json_t *requestJson(Method method, std::string url, json_t *dataJ) { // Set HTTP method switch (method) { - case GET: + case METHOD_GET: // This is CURL's default break; - case POST: + case METHOD_POST: curl_easy_setopt(curl, CURLOPT_POST, true); break; - case PUT: + case METHOD_PUT: curl_easy_setopt(curl, CURLOPT_PUT, true); break; - case DELETE: + case METHOD_DELETE: curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE"); break; } diff --git a/src/plugin.cpp b/src/plugin.cpp index 4c85387e..1e6d6e4f 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -351,7 +351,7 @@ void logIn(const std::string &email, const std::string &password) { json_object_set(reqJ, "password", json_string(password.c_str())); std::string url = app::API_URL; url += "/token"; - json_t *resJ = network::requestJson(network::POST, url, reqJ); + json_t *resJ = network::requestJson(network::METHOD_POST, url, reqJ); json_decref(reqJ); if (!resJ) { @@ -392,7 +392,7 @@ void queryUpdates() { json_object_set(pluginsReqJ, "token", json_string(settings::token.c_str())); std::string pluginsUrl = app::API_URL; pluginsUrl += "/plugins"; - json_t *pluginsResJ = network::requestJson(network::GET, pluginsUrl, pluginsReqJ); + json_t *pluginsResJ = network::requestJson(network::METHOD_GET, pluginsUrl, pluginsReqJ); json_decref(pluginsReqJ); if (!pluginsResJ) { WARN("Request for user's plugins failed"); @@ -411,7 +411,7 @@ void queryUpdates() { // Get community manifests std::string manifestsUrl = app::API_URL; manifestsUrl += "/community/manifests"; - json_t *manifestsResJ = network::requestJson(network::GET, manifestsUrl, NULL); + json_t *manifestsResJ = network::requestJson(network::METHOD_GET, manifestsUrl, NULL); if (!manifestsResJ) { WARN("Request for community manifests failed"); return; From d3548160c97af549f9d2eb8111f7be91668f7fcb Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 10 May 2019 13:23:13 -0400 Subject: [PATCH 18/41] Merge all `make *plugins` targets into `make plugins` --- Makefile | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/Makefile b/Makefile index 145d2bab..89623ffc 100644 --- a/Makefile +++ b/Makefile @@ -173,16 +173,11 @@ endif # Plugin helpers plugins: +ifdef CMD + for f in plugins/*; do (cd "$$f" && $(CMD)); done +else for f in plugins/*; do $(MAKE) -C "$$f"; done - -cleanplugins: - for f in plugins/*; do $(MAKE) -C "$$f" clean; done - -distplugins: - for f in plugins/*; do $(MAKE) -C "$$f" dist; done - -cmdplugins: - for f in plugins/*; do (cd "$$f" && ${CMD}); done +endif # Includes From e2c4dc8249f6f0de0ce80bb461a63a337d21622c Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 10 May 2019 13:27:29 -0400 Subject: [PATCH 19/41] Remove old patch before moving new temporary patch to its location. --- src/patch.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/patch.cpp b/src/patch.cpp index fc0eda6a..69840655 100644 --- a/src/patch.cpp +++ b/src/patch.cpp @@ -91,6 +91,7 @@ void PatchManager::save(std::string path) { json_dumpf(rootJ, file, JSON_INDENT(2) | JSON_REAL_PRECISION(9)); std::fclose(file); + std::remove(path.c_str()); std::rename(tmpPath.c_str(), path.c_str()); } From e693d9beef4b15301111c7805d14a0c70476e46d Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 10 May 2019 13:34:27 -0400 Subject: [PATCH 20/41] Fix submodule broken by previous commit. --- dep/glfw | 2 +- dep/nanosvg | 2 +- dep/nanovg | 2 +- dep/rtaudio | 2 +- src/engine/Engine.cpp | 15 ++++++++------- 5 files changed, 12 insertions(+), 11 deletions(-) diff --git a/dep/glfw b/dep/glfw index 7ba23eb0..d9ab59ef 160000 --- a/dep/glfw +++ b/dep/glfw @@ -1 +1 @@ -Subproject commit 7ba23eb03854dfe6ce36cc6d61cb913f76cad774 +Subproject commit d9ab59efc781c392128a449361a381fcc93cf6f3 diff --git a/dep/nanosvg b/dep/nanosvg index c1f6e209..25241c5a 160000 --- a/dep/nanosvg +++ b/dep/nanosvg @@ -1 +1 @@ -Subproject commit c1f6e209c16b18b46aa9f45d7e619acf42c29726 +Subproject commit 25241c5a8f8451d41ab1b02ab2d865b01600d949 diff --git a/dep/nanovg b/dep/nanovg index f4069e6a..1f9c8864 160000 --- a/dep/nanovg +++ b/dep/nanovg @@ -1 +1 @@ -Subproject commit f4069e6a1ad5da430fb0a9c57476d5ddc2ff89b2 +Subproject commit 1f9c8864fc556a1be4d4bf1d6bfe20cde25734b4 diff --git a/dep/rtaudio b/dep/rtaudio index b9468aa6..d27f257b 160000 --- a/dep/rtaudio +++ b/dep/rtaudio @@ -1 +1 @@ -Subproject commit b9468aa6f82fdea1f3dc364f477e859b39f0bb2a +Subproject commit d27f257b4bc827e4152cdc4d69a2e22084204afd diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index 4b1b6cf1..7fa53813 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -233,7 +233,7 @@ static void Engine_stepModules(Engine *that, int threadId) { // Step each module // for (int i = threadId; i < modulesLen; i += threadCount) { while (true) { - // Chose module + // Choose next module int i = internal->workerModuleIndex++; if (i >= modulesLen) break; @@ -277,7 +277,7 @@ static void Engine_step(Engine *that) { if (smoothModule) { Param *param = &smoothModule->params[smoothParamId]; float value = param->value; - // decay rate is 1 graphics frame + // Decay rate is 1 graphics frame const float smoothLambda = 60.f; float newValue = value + (smoothValue - value) * smoothLambda * internal->sampleTime; if (value == newValue) { @@ -377,7 +377,7 @@ static void Engine_run(Engine *that) { // Every time the that waits and locks a mutex, it steps this many frames const int mutexSteps = 128; // Time in seconds that the that is rushing ahead of the estimated clock time - double ahead = 0.0; + double aheadTime = 0.0; auto lastTime = std::chrono::high_resolution_clock::now(); while (internal->running) { @@ -390,6 +390,7 @@ static void Engine_run(Engine *that) { for (Module *module : internal->modules) { module->onSampleRateChange(); } + aheadTime = 0.0; } // Launch workers @@ -413,17 +414,17 @@ static void Engine_run(Engine *that) { } double stepTime = mutexSteps * internal->sampleTime; - ahead += stepTime; + aheadTime += stepTime; auto currTime = std::chrono::high_resolution_clock::now(); const double aheadFactor = 2.0; - ahead -= aheadFactor * std::chrono::duration(currTime - lastTime).count(); + aheadTime -= aheadFactor * std::chrono::duration(currTime - lastTime).count(); lastTime = currTime; - ahead = std::fmax(ahead, 0.0); + aheadTime = std::fmax(aheadTime, 0.0); // Avoid pegging the CPU at 100% when there are no "blocking" modules like AudioInterface, but still step audio at a reasonable rate // The number of steps to wait before possibly sleeping const double aheadMax = 1.0; // seconds - if (ahead > aheadMax) { + if (aheadTime > aheadMax) { std::this_thread::sleep_for(std::chrono::duration(stepTime)); } } From fe713d5a7a53bca8f7059a2c5e7508800d04b5a3 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sat, 11 May 2019 01:16:34 -0400 Subject: [PATCH 21/41] Add codesigning on Mac. Silently fail if settings.json is not found when loaded. --- Makefile | 13 +++++++++---- plugin.mk | 2 +- src/settings.cpp | 2 +- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index 89623ffc..b991f189 100644 --- a/Makefile +++ b/Makefile @@ -106,7 +106,7 @@ ifdef ARCH_LIN ldd dist/Rack/$(TARGET) cp plugins/Fundamental/dist/*.zip dist/Rack/Fundamental.zip # Make ZIP - cd dist && zip -5 -r Rack-$(VERSION)-$(ARCH).zip Rack + cd dist && zip -q -5 -r Rack-$(VERSION)-$(ARCH).zip Rack endif ifdef ARCH_MAC mkdir -p dist/$(TARGET).app @@ -123,8 +123,13 @@ ifdef ARCH_MAC otool -L dist/$(TARGET).app/Contents/MacOS/$(TARGET) cp plugins/Fundamental/dist/*.zip dist/$(TARGET).app/Contents/Resources/Fundamental.zip + # Clean up and sign bundle + xattr -cr dist/$(TARGET).app + codesign --sign "VCV" --verbose dist/$(TARGET).app + codesign --verify --verbose dist/$(TARGET).app + spctl --assess --verbose dist/$(TARGET).app # Make ZIP - cd dist && zip -5 -r Rack-$(VERSION)-$(ARCH).zip $(TARGET).app + cd dist && zip -q -5 -r Rack-$(VERSION)-$(ARCH).zip $(TARGET).app endif ifdef ARCH_WIN mkdir -p dist/Rack @@ -136,7 +141,7 @@ ifdef ARCH_WIN cp /mingw64/bin/libgcc_s_seh-1.dll dist/Rack/ cp plugins/Fundamental/dist/*.zip dist/Rack/Fundamental.zip # Make ZIP - cd dist && zip -5 -r Rack-$(VERSION)-$(ARCH).zip Rack + cd dist && zip -q -5 -r Rack-$(VERSION)-$(ARCH).zip Rack # Make NSIS installer # pacman -S mingw-w64-x86_64-nsis makensis -DVERSION=$(VERSION) installer.nsi @@ -153,7 +158,7 @@ endif ifdef ARCH_WIN cp libRack.a dist/Rack-SDK/ endif - cd dist && zip -5 -r Rack-SDK-$(VERSION).zip Rack-SDK + cd dist && zip -q -5 -r Rack-SDK-$(VERSION).zip Rack-SDK # Obviously this will only work if you have the private keys to my server diff --git a/plugin.mk b/plugin.mk index 6d58c5e5..f0a92dda 100644 --- a/plugin.mk +++ b/plugin.mk @@ -62,7 +62,7 @@ endif @# Copy distributables cp -R $(DISTRIBUTABLES) dist/$(SLUG)/ @# Create ZIP package - cd dist && zip -5 -r $(SLUG)-$(VERSION)-$(ARCH).zip $(SLUG) + cd dist && zip -q -5 -r $(SLUG)-$(VERSION)-$(ARCH).zip $(SLUG) install: dist cp dist/$(SLUG)-$(VERSION)-$(ARCH).zip $(RACK_USER_DIR)/plugins/ diff --git a/src/settings.cpp b/src/settings.cpp index a722a284..dc4afd2b 100644 --- a/src/settings.cpp +++ b/src/settings.cpp @@ -248,7 +248,7 @@ void load(const std::string &path) { INFO("Loading settings %s", path.c_str()); FILE *file = fopen(path.c_str(), "r"); if (!file) - throw UserException(string::f("Could not load settings file %s", path.c_str())); + return; DEFER({ fclose(file); }); From 4fe3e79181a77e71a90758fe427a725f391a7733 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sat, 11 May 2019 06:25:03 -0400 Subject: [PATCH 22/41] Ignore untracked files in submodules. --- .gitignore | 1 + .gitmodules | 6 ++++++ 2 files changed, 7 insertions(+) diff --git a/.gitignore b/.gitignore index 887392fb..c6f63346 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ /libRack.a /dep /plugins +/disabledplugins /build /dist /patches diff --git a/.gitmodules b/.gitmodules index b58bc96c..1d1633c1 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,18 +1,24 @@ [submodule "dep/nanovg"] path = dep/nanovg url = https://github.com/memononen/nanovg.git + ignore = untracked [submodule "dep/nanosvg"] path = dep/nanosvg url = https://github.com/memononen/nanosvg.git + ignore = untracked [submodule "dep/osdialog"] path = dep/osdialog url = https://github.com/AndrewBelt/osdialog.git + ignore = untracked [submodule "dep/oui-blendish"] path = dep/oui-blendish url = https://github.com/AndrewBelt/oui-blendish.git + ignore = untracked [submodule "dep/rtaudio"] path = dep/rtaudio url = https://github.com/thestk/rtaudio.git + ignore = untracked [submodule "dep/glfw"] path = dep/glfw url = https://github.com/AndrewBelt/glfw.git + ignore = untracked \ No newline at end of file From 10fa872dc660c4251004c0d47206082511751ce3 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sat, 11 May 2019 08:47:57 -0400 Subject: [PATCH 23/41] Clean up DSP headers. --- include/dsp/common.hpp | 9 ++- include/dsp/digital.hpp | 114 ++++++++++++++------------------------ include/dsp/fft.hpp | 12 ++-- include/dsp/filter.hpp | 23 +++----- include/dsp/frame.hpp | 17 ------ include/dsp/minblep.hpp | 2 +- include/dsp/ode.hpp | 6 +- include/dsp/resampler.hpp | 21 ++++--- include/dsp/vumeter.hpp | 6 +- include/dsp/window.hpp | 2 +- include/math.hpp | 29 ++++++---- include/rack.hpp | 1 - include/rack0.hpp | 1 + src/dsp/minblep.cpp | 8 +-- 14 files changed, 105 insertions(+), 146 deletions(-) delete mode 100644 include/dsp/frame.hpp diff --git a/include/dsp/common.hpp b/include/dsp/common.hpp index 570d0d61..6411f74d 100644 --- a/include/dsp/common.hpp +++ b/include/dsp/common.hpp @@ -5,7 +5,7 @@ namespace rack { -/** Digital signal processing routines for plugins +/** Digital signal processing routines */ namespace dsp { @@ -69,5 +69,12 @@ inline float exponentialBipolar(float b, float x) { } +/** Useful for storing arrays of samples in ring buffers and casting them to `float*` to be used by interleaved processors, like SampleRateConverter */ +template +struct Frame { + float samples[CHANNELS]; +}; + + } // namespace dsp } // namespace rack diff --git a/include/dsp/digital.hpp b/include/dsp/digital.hpp index b8cce2fd..5fa900b9 100644 --- a/include/dsp/digital.hpp +++ b/include/dsp/digital.hpp @@ -6,87 +6,64 @@ namespace rack { namespace dsp { +/** Detects when a boolean changes from false to true */ +struct BooleanTrigger { + bool state = true; + + void reset() { + state = true; + } + + bool process(bool state) { + bool triggered = (state && !this->state); + this->state = state; + return triggered; + } +}; + + /** Turns HIGH when value reaches 1.f, turns LOW when value reaches 0.f. */ struct SchmittTrigger { - enum State { - LOW, - HIGH, - UNKNOWN - }; - State state; - - SchmittTrigger() { - reset(); - } + bool state = true; void reset() { - state = UNKNOWN; + state = true; } /** Updates the state of the Schmitt Trigger given a value. Returns true if triggered, i.e. the value increases from 0 to 1. If different trigger thresholds are needed, use - process(math::rescale(in, low, high, 0.f, 1.f)) + + process(rescale(in, low, high, 0.f, 1.f)) + for example. */ bool process(float in) { - switch (state) { - case LOW: - if (in >= 1.f) { - state = HIGH; - return true; - } - break; - case HIGH: - if (in <= 0.f) { - state = LOW; - } - break; - default: - if (in >= 1.f) { - state = HIGH; - } - else if (in <= 0.f) { - state = LOW; - } - break; + if (state) { + // HIGH to LOW + if (in <= 0.f) { + state = false; + } + } + else { + // LOW to HIGH + if (in >= 1.f) { + state = true; + return true; + } } return false; } bool isHigh() { - return state == HIGH; - } -}; - - -/** Detects when a boolean changes from false to true */ -struct BooleanTrigger { - bool state; - - BooleanTrigger() { - reset(); - } - - void reset() { - state = true; - } - - bool process(bool state) { - bool triggered = (state && !this->state); - this->state = state; - return triggered; + return state; } }; /** When triggered, holds a high value for a specified time before going low again */ struct PulseGenerator { - float remaining; - - PulseGenerator() { - reset(); - } + float remaining = 0.f; /** Immediately disables the pulse */ void reset() { @@ -113,16 +90,13 @@ struct PulseGenerator { struct Timer { - float time; - - Timer() { - reset(); - } + float time = 0.f; void reset() { time = 0.f; } + /** Returns the time since last reset or initialization. */ float process(float deltaTime) { time += deltaTime; return time; @@ -131,26 +105,22 @@ struct Timer { struct ClockDivider { - int clock; - int division = 1; - - ClockDivider() { - reset(); - } + uint32_t clock = 0; + uint32_t division = 1; void reset() { clock = 0; } - void setDivision(int division) { + void setDivision(uint32_t division) { this->division = division; } - int getDivision() { + uint32_t getDivision() { return division; } - int getClock() { + uint32_t getClock() { return clock; } diff --git a/include/dsp/fft.hpp b/include/dsp/fft.hpp index 323ec157..2aec33e1 100644 --- a/include/dsp/fft.hpp +++ b/include/dsp/fft.hpp @@ -7,13 +7,16 @@ namespace rack { namespace dsp { -template -T *alignedNew(size_t len) { +/** Allocates an array to 64-byte boundaries. +Must call alignedFree() on the buffer to free. +*/ +template +T *alignedMalloc(size_t len) { return (T*) pffft_aligned_malloc(len * sizeof(T)); } -template -void alignedDelete(T *p) { +template +void alignedFree(T *p) { pffft_aligned_free(p); } @@ -21,6 +24,7 @@ void alignedDelete(T *p) { /** Real-valued FFT context. Wrapper for [PFFFT](https://bitbucket.org/jpommier/pffft/) `length` must be a multiple of 32. +Buffers must be aligned to 16-byte boundaries, e.g. with alignedMalloc(). */ struct RealFFT { PFFFT_Setup *setup; diff --git a/include/dsp/filter.hpp b/include/dsp/filter.hpp index 6c9113d0..909c6137 100644 --- a/include/dsp/filter.hpp +++ b/include/dsp/filter.hpp @@ -106,29 +106,20 @@ struct ExponentialSlewLimiter { \f$ \frac{dy}{dt} = x \lambda \f$. */ struct ExponentialFilter { - float out; + float out = 0.f; float lambda = 0.f; - ExponentialFilter() { - reset(); - } - void reset() { - out = NAN; + out = 0.f; } float process(float deltaTime, float in) { - if (std::isnan(out)) { + float y = out + (in - out) * lambda * deltaTime; + // If no change was made between the old and new output, assume float granularity is too small and snap output to input + if (out == y) out = in; - } - else { - float y = out + (in - out) * lambda * deltaTime; - // If no change was detected, assume float granularity is too small and snap output to input - if (out == y) - out = in; - else - out = y; - } + else + out = y; return out; } diff --git a/include/dsp/frame.hpp b/include/dsp/frame.hpp deleted file mode 100644 index dca99b4f..00000000 --- a/include/dsp/frame.hpp +++ /dev/null @@ -1,17 +0,0 @@ -#pragma once -#include "dsp/common.hpp" - - -namespace rack { -namespace dsp { - - -/** Useful for storing arrays of samples in ring buffers and casting them to `float*` to be used by interleaved processors, like SampleRateConverter */ -template -struct Frame { - float samples[CHANNELS]; -}; - - -} // namespace dsp -} // namespace rack diff --git a/include/dsp/minblep.hpp b/include/dsp/minblep.hpp index ea4a126d..3dd5b404 100644 --- a/include/dsp/minblep.hpp +++ b/include/dsp/minblep.hpp @@ -15,7 +15,7 @@ https://www.cs.cmu.edu/~eli/papers/icmc01-hardsync.pdf void minBlepImpulse(int z, int o, float *output); -template +template struct MinBlepGenerator { float buf[2 * Z] = {}; int pos = 0; diff --git a/include/dsp/ode.hpp b/include/dsp/ode.hpp index 8c1b4975..f50fc5b1 100644 --- a/include/dsp/ode.hpp +++ b/include/dsp/ode.hpp @@ -26,7 +26,7 @@ For example, the following solves the system x''(t) = -x(t) using a fixed timest */ /** Solves an ODE system using the 1st order Euler method */ -template +template void stepEuler(float t, float dt, float x[], int len, F f) { float k[len]; @@ -37,7 +37,7 @@ void stepEuler(float t, float dt, float x[], int len, F f) { } /** Solves an ODE system using the 2nd order Runge-Kutta method */ -template +template void stepRK2(float t, float dt, float x[], int len, F f) { float k1[len]; float k2[len]; @@ -56,7 +56,7 @@ void stepRK2(float t, float dt, float x[], int len, F f) { } /** Solves an ODE system using the 4th order Runge-Kutta method */ -template +template void stepRK4(float t, float dt, float x[], int len, F f) { float k1[len]; float k2[len]; diff --git a/include/dsp/resampler.hpp b/include/dsp/resampler.hpp index c13be368..6616160a 100644 --- a/include/dsp/resampler.hpp +++ b/include/dsp/resampler.hpp @@ -1,6 +1,5 @@ #pragma once #include "dsp/common.hpp" -#include "dsp/frame.hpp" #include "dsp/ringbuffer.hpp" #include "dsp/fir.hpp" #include "dsp/window.hpp" @@ -14,10 +13,10 @@ namespace dsp { /** Resamples by a fixed rational factor. */ -template +template struct SampleRateConverter { SpeexResamplerState *st = NULL; - int channels = CHANNELS; + int channels = MAX_CHANNELS; int quality = SPEEX_RESAMPLER_QUALITY_DEFAULT; int inRate = 44100; int outRate = 44100; @@ -31,9 +30,9 @@ struct SampleRateConverter { } } - /** Sets the number of channels to actually process. This can be at most CHANNELS. */ + /** Sets the number of channels to actually process. This can be at most MAX_CHANNELS. */ void setChannels(int channels) { - assert(channels <= CHANNELS); + assert(channels <= MAX_CHANNELS); if (channels == this->channels) return; this->channels = channels; @@ -68,13 +67,13 @@ struct SampleRateConverter { assert(st); assert(err == RESAMPLER_ERR_SUCCESS); - speex_resampler_set_input_stride(st, CHANNELS); - speex_resampler_set_output_stride(st, CHANNELS); + speex_resampler_set_input_stride(st, MAX_CHANNELS); + speex_resampler_set_output_stride(st, MAX_CHANNELS); } } /** `in` and `out` are interlaced with the number of channels */ - void process(const Frame *in, int *inFrames, Frame *out, int *outFrames) { + void process(const Frame *in, int *inFrames, Frame *out, int *outFrames) { assert(in); assert(inFrames); assert(out); @@ -95,7 +94,7 @@ struct SampleRateConverter { else { // Simply copy the buffer without conversion int frames = std::min(*inFrames, *outFrames); - std::memcpy(out, in, frames * sizeof(Frame)); + std::memcpy(out, in, frames * sizeof(Frame)); *inFrames = frames; *outFrames = frames; } @@ -104,7 +103,7 @@ struct SampleRateConverter { /** Downsamples by an integer factor. */ -template +template struct Decimator { float inBuffer[OVERSAMPLE*QUALITY]; float kernel[OVERSAMPLE*QUALITY]; @@ -139,7 +138,7 @@ struct Decimator { /** Upsamples by an integer factor. */ -template +template struct Upsampler { float inBuffer[QUALITY]; float kernel[OVERSAMPLE*QUALITY]; diff --git a/include/dsp/vumeter.hpp b/include/dsp/vumeter.hpp index 4cfc1975..8f986f1a 100644 --- a/include/dsp/vumeter.hpp +++ b/include/dsp/vumeter.hpp @@ -54,14 +54,10 @@ struct VuMeter2 { }; Mode mode = PEAK; /** Either the smoothed peak or the mean-square of the brightness, depending on the mode. */ - float v; + float v = 0.f; /** Inverse time constant in 1/seconds */ float lambda = 30.f; - VuMeter2() { - reset(); - } - void reset() { v = 0.f; } diff --git a/include/dsp/window.hpp b/include/dsp/window.hpp index e28ccc30..4cc74bd1 100644 --- a/include/dsp/window.hpp +++ b/include/dsp/window.hpp @@ -14,7 +14,7 @@ inline float hann(float p) { return 0.5f * (1.f - std::cos(2*M_PI * p)); } -/** Applies the Hann window to a signal `x`. */ +/** Multiplies the Hann window by a signal `x` of length `len` in-place. */ inline void hannWindow(float *x, int len) { for (int i = 0; i < len; i++) { x[i] *= hann((float) i / (len - 1)); diff --git a/include/math.hpp b/include/math.hpp index 1e368209..7a75df4c 100644 --- a/include/math.hpp +++ b/include/math.hpp @@ -36,7 +36,7 @@ inline int clamp(int x, int a, int b) { If `b < a`, switches the two values. */ inline int clampSafe(int x, int a, int b) { - return clamp(x, std::min(a, b), std::max(a, b)); + return (a <= b) ? clamp(x, a, b) : clamp(x, b, a); } /** Euclidean modulus. Always returns `0 <= mod < b`. @@ -101,14 +101,14 @@ inline float clamp(float x, float a, float b) { If `b < a`, switches the two values. */ inline float clampSafe(float x, float a, float b) { - return clamp(x, std::fmin(a, b), std::fmax(a, b)); + return (a <= b) ? clamp(x, a, b) : clamp(x, b, a); } /** Returns 1 for positive numbers, -1 for negative numbers, and 0 for zero. See https://en.wikipedia.org/wiki/Sign_function. */ inline float sgn(float x) { - return x > 0.f ? 1.f : x < 0.f ? -1.f : 0.f; + return x > 0.f ? 1.f : (x < 0.f ? -1.f : 0.f); } /** Converts -0.f to 0.f. Leaves all other values unchanged. */ @@ -119,9 +119,12 @@ inline float normalizeZero(float x) { /** Euclidean modulus. Always returns `0 <= mod < b`. See https://en.wikipedia.org/wiki/Euclidean_division. */ -inline float eucMod(float a, float base) { - float mod = std::fmod(a, base); - return (mod >= 0.f) ? mod : mod + base; +inline float eucMod(float a, float b) { + int mod = std::fmod(a, b); + if (mod < 0.f) { + mod += b; + } + return mod; } /** Returns whether `a` is within epsilon distance from `b`. */ @@ -131,7 +134,7 @@ inline bool isNear(float a, float b, float epsilon = 1e-6f) { /** If the magnitude of `x` if less than epsilon, return 0. */ inline float chop(float x, float epsilon = 1e-6f) { - return isNear(x, 0.f, epsilon) ? 0.f : x; + return std::fabs(x) <= epsilon ? 0.f : x; } inline float rescale(float x, float xMin, float xMax, float yMin, float yMax) { @@ -155,9 +158,9 @@ inline float interpolateLinear(const float *p, float x) { Arguments may be the same pointers. Example: - cmultf(&ar, &ai, ar, ai, br, bi); + cmultf(ar, ai, br, bi, &ar, &ai); */ -inline void complexMult(float *cr, float *ci, float ar, float ai, float br, float bi) { +inline void complexMult(float ar, float ai, float br, float bi, float *cr, float *ci) { *cr = ar * br - ai * bi; *ci = ar * bi + ai * br; } @@ -202,6 +205,9 @@ struct Vec { float dot(Vec b) const { return x * b.x + y * b.y; } + float arg() const { + return std::atan2(y, x); + } float norm() const { return std::hypot(x, y); } @@ -229,6 +235,9 @@ struct Vec { Vec max(Vec b) const { return Vec(std::fmax(x, b.x), std::fmax(y, b.y)); } + Vec abs() const { + return Vec(std::fabs(x), std::fabs(y)); + } Vec round() const { return Vec(std::round(x), std::round(y)); } @@ -323,7 +332,7 @@ struct Rect { r.pos.y = math::clampSafe(pos.y, bound.pos.y, bound.pos.y + bound.size.y - size.y); return r; } - /** Expands this Rect to contain `b`. */ + /** Returns the bounding box of the union of `this` and `b`. */ Rect expand(Rect b) const { Rect r; r.pos.x = std::fmin(pos.x, b.pos.x); diff --git a/include/rack.hpp b/include/rack.hpp index 947be15a..fa2cbf82 100644 --- a/include/rack.hpp +++ b/include/rack.hpp @@ -84,7 +84,6 @@ #include "dsp/fft.hpp" #include "dsp/filter.hpp" #include "dsp/fir.hpp" -#include "dsp/frame.hpp" #include "dsp/minblep.hpp" #include "dsp/ode.hpp" #include "dsp/resampler.hpp" diff --git a/include/rack0.hpp b/include/rack0.hpp index 48417570..ad05d544 100644 --- a/include/rack0.hpp +++ b/include/rack0.hpp @@ -45,6 +45,7 @@ DEPRECATED inline float rescalef(float x, float a, float b, float yMin, float yM DEPRECATED inline float crossf(float a, float b, float frac) {return crossfade(a, b, frac);} DEPRECATED inline float interpf(const float *p, float x) {return interpolateLinear(p, x);} DEPRECATED inline void cmultf(float *cr, float *ci, float ar, float ai, float br, float bi) {return complexMult(cr, ci, ar, ai, br, bi);} +DEPRECATED inline void complexMult(float *cr, float *ci, float ar, float ai, float br, float bi) {complexMult(ar, ai, br, bi, cr, ci);} //////////////////// // random diff --git a/src/dsp/minblep.cpp b/src/dsp/minblep.cpp index 0eddb5e3..32cb34a4 100644 --- a/src/dsp/minblep.cpp +++ b/src/dsp/minblep.cpp @@ -10,7 +10,7 @@ namespace dsp { void minBlepImpulse(int z, int o, float *output) { // Symmetric sinc array with `z` zero-crossings on each side int n = 2 * z * o; - float *x = alignedNew(n); + float *x = alignedMalloc(n); for (int i = 0; i < n; i++) { float p = math::rescale((float) i, 0.f, (float) (n - 1), (float) -z, (float) z); x[i] = sinc(p); @@ -20,7 +20,7 @@ void minBlepImpulse(int z, int o, float *output) { blackmanHarrisWindow(x, n); // Real cepstrum - float *fx = alignedNew(2*n); + float *fx = alignedMalloc(2*n); RealFFT rfft(n); rfft.rfft(x, fx); // fx = log(abs(fx)) @@ -73,8 +73,8 @@ void minBlepImpulse(int z, int o, float *output) { std::memcpy(output, x, n * sizeof(float)); // Cleanup - alignedDelete(x); - alignedDelete(fx); + alignedFree(x); + alignedFree(fx); } From 8d63d198ead872b0fa06fbdc0ac92eb559b8ecc3 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sat, 11 May 2019 09:27:17 -0400 Subject: [PATCH 24/41] Make random state thread-local. --- include/plugin.hpp | 14 +++++++------- include/random.hpp | 4 +++- src/engine/Engine.cpp | 6 +++++- src/random.cpp | 4 +--- 4 files changed, 16 insertions(+), 12 deletions(-) diff --git a/include/plugin.hpp b/include/plugin.hpp index 1fc55184..9977e0fb 100644 --- a/include/plugin.hpp +++ b/include/plugin.hpp @@ -14,13 +14,6 @@ namespace rack { namespace plugin { -struct Update { - std::string pluginSlug; - std::string version; - std::string changelogUrl; -}; - - void init(); void destroy(); void logIn(const std::string &email, const std::string &password); @@ -36,6 +29,13 @@ std::string normalizeTag(const std::string &tag); bool isSlugValid(const std::string &slug); +struct Update { + std::string pluginSlug; + std::string version; + std::string changelogUrl; +}; + + extern const std::set allowedTags; extern std::vector plugins; diff --git a/include/random.hpp b/include/random.hpp index 23af5a22..79b935dc 100644 --- a/include/random.hpp +++ b/include/random.hpp @@ -11,7 +11,9 @@ namespace rack { namespace random { -/** Seeds the RNG with the current time */ +/** Initializes the thread-local RNG state. +Must call per-thread, otherwise the RNG will always return 0. +*/ void init(); /** Returns a uniform random uint32_t from 0 to UINT32_MAX */ uint32_t u32(); diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index 7fa53813..d9aa252c 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -150,6 +150,7 @@ struct EngineWorker { void start() { thread = std::thread([&] { + random::init(); run(); }); } @@ -436,7 +437,10 @@ static void Engine_run(Engine *that) { void Engine::start() { internal->running = true; - internal->thread = std::thread(Engine_run, this); + internal->thread = std::thread([&] { + random::init(); + Engine_run(this); + }); } void Engine::stop() { diff --git a/src/random.cpp b/src/random.cpp index a150e712..18b68186 100644 --- a/src/random.cpp +++ b/src/random.cpp @@ -11,7 +11,7 @@ namespace random { // xoroshiro128+ // from http://xoroshiro.di.unimi.it/xoroshiro128plus.c -static uint64_t xoroshiro128plus_state[2] = {}; +thread_local uint64_t xoroshiro128plus_state[2]; static uint64_t rotl(const uint64_t x, int k) { return (x << k) | (x >> (64 - k)); @@ -30,8 +30,6 @@ static uint64_t xoroshiro128plus_next(void) { } void init() { - // Only allow the seed to be initialized once during the lifetime of the program. - assert(xoroshiro128plus_state[0] == 0 && xoroshiro128plus_state[1] == 0); struct timeval tv; gettimeofday(&tv, NULL); xoroshiro128plus_state[0] = tv.tv_sec; From afd6d4bb8e78f279c7f5f3b4ac76fef81269ed4c Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sat, 11 May 2019 11:08:20 -0400 Subject: [PATCH 25/41] Clean up various headers. --- include/app/SvgScrew.hpp | 5 ++++- include/common.hpp | 32 +++++++++++++++++++++++++------- include/componentlibrary.hpp | 22 +++++++--------------- include/event.hpp | 22 ++++++++++++++++++++++ include/helpers.hpp | 4 ++-- include/logger.hpp | 15 +++++++++------ include/rack.hpp | 1 + include/string.hpp | 5 +++-- include/system.hpp | 8 +++++--- include/window.hpp | 21 --------------------- src/app/SvgScrew.cpp | 12 +++++++++++- src/patch.cpp | 3 +-- src/plugin.cpp | 6 +++--- src/system.cpp | 20 ++++++++++++++++---- 14 files changed, 109 insertions(+), 67 deletions(-) diff --git a/include/app/SvgScrew.hpp b/include/app/SvgScrew.hpp index a0810129..bc577649 100644 --- a/include/app/SvgScrew.hpp +++ b/include/app/SvgScrew.hpp @@ -1,5 +1,6 @@ #pragma once #include "common.hpp" +#include "widget/Widget.hpp" #include "widget/FramebufferWidget.hpp" #include "widget/SvgWidget.hpp" @@ -9,10 +10,12 @@ namespace app { /** If you don't add these to your ModuleWidget, they will fall out of the rack... */ -struct SvgScrew : widget::FramebufferWidget { +struct SvgScrew : widget::Widget { + widget::FramebufferWidget *fb; widget::SvgWidget *sw; SvgScrew(); + void setSvg(std::shared_ptr svg); }; diff --git a/include/common.hpp b/include/common.hpp index 757f35e4..3c1aa373 100644 --- a/include/common.hpp +++ b/include/common.hpp @@ -21,6 +21,7 @@ namespace rack { /** Deprecation notice for functions E.g. + DEPRECATED void foo(); */ #if defined(__GNUC__) || defined(__clang__) @@ -33,9 +34,12 @@ E.g. /** Concatenates two literals or two macros Example: + #define COUNT 42 CONCAT(myVariable, COUNT) + expands to + myVariable42 */ #define CONCAT_LITERAL(x, y) x ## y @@ -44,10 +48,14 @@ expands to /** Surrounds raw text with quotes Example: + #define NAME "world" printf("Hello " TOSTRING(NAME)) + expands to + printf("Hello " "world") + and of course the C++ lexer/parser then concatenates the string literals. */ #define TOSTRING_LITERAL(x) #x @@ -60,26 +68,35 @@ and of course the C++ lexer/parser then concatenates the string literals. /** Reserve space for `count` enums starting with `name`. Example: + enum Foo { ENUMS(BAR, 14), BAZ }; - BAR + 0 to BAR + 13 is reserved. BAZ has a value of 14. +`BAR + 0` to `BAR + 13` is reserved. `BAZ` has a value of 14. */ #define ENUMS(name, count) name, name ## _LAST = name + (count) - 1 /** References binary files compiled into the program. For example, to include a file "Test.dat" directly into your program binary, add + BINARIES += Test.dat + to your Makefile and declare + BINARY(Test_dat); + at the root of a .c or .cpp source file. Note that special characters are replaced with "_". Then use + BINARY_START(Test_dat) BINARY_END(Test_dat) + to reference the data beginning and end as a void* array, and + BINARY_SIZE(Test_dat) + to get its size in bytes. */ #if defined ARCH_MAC @@ -99,14 +116,15 @@ to get its size in bytes. /** C#-style property constructor Example: + Foo *foo = construct(&Foo::greeting, "Hello world", &Foo::legs, 2); */ -template +template T *construct() { return new T; } -template +template T *construct(F f, V v, Args... args) { T *o = construct(args...); o->*f = v; @@ -115,21 +133,21 @@ T *construct(F f, V v, Args... args) { /** Defers code until the scope is destructed From http://www.gingerbill.org/article/defer-in-cpp.html - Example: + file = fopen(...); DEFER({ fclose(file); }); */ -template +template struct DeferWrapper { F f; DeferWrapper(F f) : f(f) {} ~DeferWrapper() { f(); } }; -template +template DeferWrapper deferWrapper(F f) { return DeferWrapper(f); } @@ -137,7 +155,7 @@ DeferWrapper deferWrapper(F f) { #define DEFER(code) auto CONCAT(_defer_, __COUNTER__) = rack::deferWrapper([&]() code) -/** Reports a string to the user */ +/** An exception meant to be shown to the user */ struct UserException : std::runtime_error { UserException(const std::string &msg) : std::runtime_error(msg) {} }; diff --git a/include/componentlibrary.hpp b/include/componentlibrary.hpp index 3c712a2d..e7166a8b 100644 --- a/include/componentlibrary.hpp +++ b/include/componentlibrary.hpp @@ -300,9 +300,12 @@ struct SynthTechAlco : app::SvgKnob { minAngle = -0.82*M_PI; maxAngle = 0.82*M_PI; setSvg(APP->window->loadSvg(asset::system("res/ComponentLibrary/SynthTechAlco.svg"))); + // Add cap + widget::FramebufferWidget *capFb = new widget::FramebufferWidget; widget::SvgWidget *cap = new widget::SvgWidget; cap->setSvg(APP->window->loadSvg(asset::system("res/ComponentLibrary/SynthTechAlco_cap.svg"))); - addChild(cap); + capFb->addChild(cap); + addChild(capFb); } }; @@ -460,15 +463,6 @@ struct RedGreenBlueLight : GrayModuleLightWidget { } }; -struct RGBLight : app::ModuleLightWidget { - RGBLight() { - addBaseColor(nvgRGBf(1, 0, 0)); - addBaseColor(nvgRGBf(0, 1, 0)); - addBaseColor(nvgRGBf(0, 0, 1)); - } -}; - - /** Based on the size of 5mm LEDs */ template struct LargeLight : BASE { @@ -501,7 +495,7 @@ struct TinyLight : BASE { } }; -/** A light to displayed over PB61303. Must add a color by subclassing or templating. */ +/** A light for displaying on top of PB61303. Must add a color by subclassing or templating. */ template struct LEDBezelLight : BASE { LEDBezelLight() { @@ -608,15 +602,13 @@ struct PB61303 : app::SvgSwitch { struct ScrewSilver : app::SvgScrew { ScrewSilver() { - sw->setSvg(APP->window->loadSvg(asset::system("res/ComponentLibrary/ScrewSilver.svg"))); - box.size = sw->box.size; + setSvg(APP->window->loadSvg(asset::system("res/ComponentLibrary/ScrewSilver.svg"))); } }; struct ScrewBlack : app::SvgScrew { ScrewBlack() { - sw->setSvg(APP->window->loadSvg(asset::system("res/ComponentLibrary/ScrewBlack.svg"))); - box.size = sw->box.size; + setSvg(APP->window->loadSvg(asset::system("res/ComponentLibrary/ScrewBlack.svg"))); } }; diff --git a/include/event.hpp b/include/event.hpp index 6ce81894..f8953dcb 100644 --- a/include/event.hpp +++ b/include/event.hpp @@ -5,6 +5,28 @@ #include + +/** Remaps Ctrl to Cmd on Mac +Use this instead of GLFW_MOD_CONTROL, since Cmd should be used on Mac in place of Ctrl on Linux/Windows. +*/ +#if defined ARCH_MAC + #define RACK_MOD_CTRL GLFW_MOD_SUPER + #define RACK_MOD_CTRL_NAME "Cmd" +#else + #define RACK_MOD_CTRL GLFW_MOD_CONTROL + #define RACK_MOD_CTRL_NAME "Ctrl" +#endif +#define RACK_MOD_SHIFT_NAME "Shift" +#define RACK_MOD_ALT_NAME "Alt" + +/** Filters actual mod keys from the mod flags. +Use this if you don't care about GLFW_MOD_CAPS_LOCK and GLFW_MOD_NUM_LOCK. +Example usage: + if ((e.mod & RACK_MOD_MASK) == (RACK_MOD_CTRL | GLFW_MOD_SHIFT)) ... +*/ +#define RACK_MOD_MASK (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT | GLFW_MOD_SUPER) + + namespace rack { diff --git a/include/helpers.hpp b/include/helpers.hpp index 057695d5..574bff47 100644 --- a/include/helpers.hpp +++ b/include/helpers.hpp @@ -52,8 +52,8 @@ TWidget *createWidget(math::Vec pos) { template TWidget *createWidgetCentered(math::Vec pos) { - TWidget *o = new TWidget; - o->box.pos = pos.minus(o->box.size.div(2));; + TWidget *o = createWidget(pos); + o->box.pos = o->box.pos.minus(o->box.size.div(2)); return o; } diff --git a/include/logger.hpp b/include/logger.hpp index f77ff97f..e35cc12f 100644 --- a/include/logger.hpp +++ b/include/logger.hpp @@ -2,14 +2,17 @@ /** Example usage: + DEBUG("error: %d", errno); + will print something like + [0.123 debug myfile.cpp:45] error: 67 */ -#define DEBUG(format, ...) rack::logger::log(rack::logger::DEBUG_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) -#define INFO(format, ...) rack::logger::log(rack::logger::INFO_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) -#define WARN(format, ...) rack::logger::log(rack::logger::WARN_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) -#define FATAL(format, ...) rack::logger::log(rack::logger::FATAL_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) +#define DEBUG(format, ...) logger::log(rack::logger::DEBUG_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) +#define INFO(format, ...) logger::log(rack::logger::INFO_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) +#define WARN(format, ...) logger::log(rack::logger::WARN_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) +#define FATAL(format, ...) logger::log(rack::logger::FATAL_LEVEL, __FILE__, __LINE__, format, ##__VA_ARGS__) namespace rack { @@ -29,8 +32,8 @@ enum Level { void init(); void destroy(); -/** Do not use this function directly. Use the macros below. -Thread-safe. +/** Do not use this function directly. Use the macros above. +Thread-safe, meaning messages cannot overlap each other in the log. */ void log(Level level, const char *filename, int line, const char *format, ...); diff --git a/include/rack.hpp b/include/rack.hpp index fa2cbf82..d681d596 100644 --- a/include/rack.hpp +++ b/include/rack.hpp @@ -101,6 +101,7 @@ namespace rack { /** Define this macro before including this header to prevent common namespaces from being included in the main `rack::` namespace. */ #ifndef RACK_FLATTEN_NAMESPACES // Import some namespaces for convenience +using namespace logger; using namespace math; using namespace widget; using namespace ui; diff --git a/include/string.hpp b/include/string.hpp index 96cd07e6..a75c9d14 100644 --- a/include/string.hpp +++ b/include/string.hpp @@ -13,14 +13,15 @@ namespace string { /** Converts a UTF-16/32 string (depending on the size of wchar_t) to a UTF-8 string. */ std::string fromWstring(const std::wstring &s); std::wstring toWstring(const std::string &s); -/** Converts a `printf()` format string and optional arguments into a std::string -Remember that "%s" must reference a `char *`, so use `.c_str()` for `std::string`s. +/** Converts a `printf()` format string and optional arguments into a std::string. +Remember that "%s" must reference a `char *`, so use `.c_str()` for `std::string`s, otherwise you might get binary garbage. */ std::string f(const char *format, ...); /** Replaces all characters to lowercase letters */ std::string lowercase(const std::string &s); /** Replaces all characters to uppercase letters */ std::string uppercase(const std::string &s); +/** Removes whitespace from beginning and end of string. */ std::string trim(const std::string &s); /** Truncates and adds "..." to a string, not exceeding `len` characters */ std::string ellipsize(const std::string &s, size_t len); diff --git a/include/system.hpp b/include/system.hpp index ec9dfded..a685b981 100644 --- a/include/system.hpp +++ b/include/system.hpp @@ -12,11 +12,13 @@ namespace system { /** Returns a list of all entries (directories, files, symbols) in a directory. */ -std::list listEntries(const std::string &path); +std::list getEntries(const std::string &path); /** Returns whether the given path is a file. */ bool isFile(const std::string &path); /** Returns whether the given path is a directory. */ bool isDirectory(const std::string &path); +/** Moves a file. */ +void moveFile(const std::string &srcPath, const std::string &destPath); /** Copies a file. */ void copyFile(const std::string &srcPath, const std::string &destPath); /** Creates a directory. @@ -36,12 +38,12 @@ Shell injection is possible, so make sure the URL is trusted or hard coded. May block, so open in a new thread. */ void openBrowser(const std::string &url); -/** Opens Explorer, Finder, etc at the folder location. */ +/** Opens Windows Explorer, Finder, etc at the folder location. */ void openFolder(const std::string &path); /** Runs an executable without blocking. The launched process will continue running if the current process is closed. */ -void runProcessAsync(const std::string &path); +void runProcessDetached(const std::string &path); std::string getOperatingSystemInfo(); diff --git a/include/window.hpp b/include/window.hpp index 4a58d70c..8ada93ae 100644 --- a/include/window.hpp +++ b/include/window.hpp @@ -14,27 +14,6 @@ #include -/** Remaps Ctrl to Cmd on Mac -Use this instead of GLFW_MOD_CONTROL, since Cmd should be used on Mac in place of Ctrl on Linux/Windows. -*/ -#if defined ARCH_MAC - #define RACK_MOD_CTRL GLFW_MOD_SUPER - #define RACK_MOD_CTRL_NAME "Cmd" -#else - #define RACK_MOD_CTRL GLFW_MOD_CONTROL - #define RACK_MOD_CTRL_NAME "Ctrl" -#endif -#define RACK_MOD_SHIFT_NAME "Shift" -#define RACK_MOD_ALT_NAME "Alt" - -/** Filters actual mod keys from the mod flags. -Use this if you don't care about GLFW_MOD_CAPS_LOCK and GLFW_MOD_NUM_LOCK. -Example usage: - if ((e.mod & RACK_MOD_MASK) == (RACK_MOD_CTRL | GLFW_MOD_SHIFT)) ... -*/ -#define RACK_MOD_MASK (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT | GLFW_MOD_SUPER) - - namespace rack { diff --git a/src/app/SvgScrew.cpp b/src/app/SvgScrew.cpp index 5b8bb335..6636e543 100644 --- a/src/app/SvgScrew.cpp +++ b/src/app/SvgScrew.cpp @@ -6,8 +6,18 @@ namespace app { SvgScrew::SvgScrew() { + fb = new widget::FramebufferWidget; + addChild(fb); + sw = new widget::SvgWidget; - addChild(sw); + fb->addChild(sw); +} + + +void SvgScrew::setSvg(std::shared_ptr svg) { + sw->setSvg(svg); + fb->box.size = sw->box.size; + box.size = sw->box.size; } diff --git a/src/patch.cpp b/src/patch.cpp index 69840655..7a20524f 100644 --- a/src/patch.cpp +++ b/src/patch.cpp @@ -91,8 +91,7 @@ void PatchManager::save(std::string path) { json_dumpf(rootJ, file, JSON_INDENT(2) | JSON_REAL_PRECISION(9)); std::fclose(file); - std::remove(path.c_str()); - std::rename(tmpPath.c_str(), path.c_str()); + system::moveFile(tmpPath, path); } void PatchManager::saveDialog() { diff --git a/src/plugin.cpp b/src/plugin.cpp index 1e6d6e4f..a4295693 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -149,7 +149,7 @@ static bool loadPlugin(std::string path) { // Search for presets for (Model *model : plugin->models) { std::string presetDir = asset::plugin(plugin, "presets/" + model->slug); - for (const std::string &presetPath : system::listEntries(presetDir)) { + for (const std::string &presetPath : system::getEntries(presetDir)) { model->presetPaths.push_back(presetPath); } } @@ -190,7 +190,7 @@ static bool syncUpdate(const Update &update) { static void loadPlugins(std::string path) { std::string message; - for (std::string pluginPath : system::listEntries(path)) { + for (std::string pluginPath : system::getEntries(path)) { if (!system::isDirectory(pluginPath)) continue; if (!loadPlugin(pluginPath)) { @@ -271,7 +271,7 @@ static int extractZip(const char *filename, const char *path) { static void extractPackages(const std::string &path) { std::string message; - for (std::string packagePath : system::listEntries(path)) { + for (std::string packagePath : system::getEntries(path)) { if (string::filenameExtension(packagePath) != "zip") continue; INFO("Extracting package %s", packagePath.c_str()); diff --git a/src/system.cpp b/src/system.cpp index 3c7d8cbf..c7cb3f94 100644 --- a/src/system.cpp +++ b/src/system.cpp @@ -25,7 +25,7 @@ namespace rack { namespace system { -std::list listEntries(const std::string &path) { +std::list getEntries(const std::string &path) { std::list filenames; DIR *dir = opendir(path.c_str()); if (dir) { @@ -56,14 +56,23 @@ bool isDirectory(const std::string &path) { return S_ISDIR(statbuf.st_mode); } +void moveFile(const std::string &srcPath, const std::string &destPath) { + std::remove(destPath.c_str()); + // Whether this overwrites existing files is implementation-defined. + // i.e. Mingw64 fails to overwrite. + // This is why we remove the file above. + std::rename(srcPath.c_str(), destPath.c_str()); +} + void copyFile(const std::string &srcPath, const std::string &destPath) { - // Open files + // Open source FILE *source = fopen(srcPath.c_str(), "rb"); if (!source) return; DEFER({ fclose(source); }); + // Open destination FILE *dest = fopen(destPath.c_str(), "wb"); if (!dest) return; @@ -93,7 +102,6 @@ void createDirectory(const std::string &path) { } int getLogicalCoreCount() { - // TODO Return the physical cores, not logical cores. return std::thread::hardware_concurrency(); } @@ -199,7 +207,7 @@ void openFolder(const std::string &path) { } -void runProcessAsync(const std::string &path) { +void runProcessDetached(const std::string &path) { #if defined ARCH_WIN STARTUPINFOW startupInfo; PROCESS_INFORMATION processInfo; @@ -212,6 +220,9 @@ void runProcessAsync(const std::string &path) { CreateProcessW(pathW.c_str(), NULL, NULL, NULL, false, 0, NULL, NULL, &startupInfo, &processInfo); +#else + // Not implemented on Linux or Mac + assert(0); #endif } @@ -226,6 +237,7 @@ std::string getOperatingSystemInfo() { ZeroMemory(&info, sizeof(info)); info.dwOSVersionInfoSize = sizeof(info); GetVersionExW(&info); + // See https://docs.microsoft.com/en-us/windows/desktop/api/winnt/ns-winnt-_osversioninfoa for a list of Windows version numbers. return string::f("Windows %u.%u", info.dwMajorVersion, info.dwMinorVersion); #endif } From 5e0378cb5ac5c6d399f8f25b87feabf43edaa9e7 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sat, 11 May 2019 15:58:12 -0400 Subject: [PATCH 26/41] Clean up app namespace. --- include/app/AudioWidget.hpp | 8 +------- include/app/CableWidget.hpp | 1 + include/app/CircularShadow.hpp | 1 + include/app/LightWidget.hpp | 1 + include/app/MidiWidget.hpp | 8 +------- include/app/ModuleLightWidget.hpp | 1 + include/app/ModuleWidget.hpp | 9 +++++---- include/app/MultiLightWidget.hpp | 1 + include/app/Scene.hpp | 4 ++-- include/app/SvgKnob.hpp | 3 ++- include/app/common.hpp | 6 +++--- src/Core/Blank.cpp | 12 +++++++++--- src/app/AudioWidget.cpp | 1 - src/app/Knob.cpp | 6 ++++++ src/app/MidiWidget.cpp | 1 - src/app/ModuleWidget.cpp | 28 ++++++++++++++-------------- src/app/PortWidget.cpp | 14 +++++++++++++- src/app/Switch.cpp | 3 +++ src/app/common.cpp | 15 +++++++++++++++ 19 files changed, 79 insertions(+), 44 deletions(-) create mode 100644 src/app/common.cpp diff --git a/include/app/AudioWidget.hpp b/include/app/AudioWidget.hpp index f2e1b340..6ee2a540 100644 --- a/include/app/AudioWidget.hpp +++ b/include/app/AudioWidget.hpp @@ -1,16 +1,10 @@ #pragma once #include "app/common.hpp" #include "app/LedDisplay.hpp" +#include "audio.hpp" namespace rack { - - -namespace audio { - struct Port; -} - - namespace app { diff --git a/include/app/CableWidget.hpp b/include/app/CableWidget.hpp index 83f2e5c7..198057e4 100644 --- a/include/app/CableWidget.hpp +++ b/include/app/CableWidget.hpp @@ -16,6 +16,7 @@ struct CableWidget : widget::OpaqueWidget { PortWidget *inputPort = NULL; PortWidget *hoveredOutputPort = NULL; PortWidget *hoveredInputPort = NULL; + /** Owned. */ engine::Cable *cable; NVGcolor color; diff --git a/include/app/CircularShadow.hpp b/include/app/CircularShadow.hpp index 5041d74b..06099d30 100644 --- a/include/app/CircularShadow.hpp +++ b/include/app/CircularShadow.hpp @@ -10,6 +10,7 @@ namespace app { struct CircularShadow : widget::TransparentWidget { float blurRadius; float opacity; + CircularShadow(); void draw(const DrawArgs &args) override; }; diff --git a/include/app/LightWidget.hpp b/include/app/LightWidget.hpp index ff76e5d6..e26a2234 100644 --- a/include/app/LightWidget.hpp +++ b/include/app/LightWidget.hpp @@ -11,6 +11,7 @@ struct LightWidget : widget::TransparentWidget { NVGcolor bgColor = nvgRGBA(0, 0, 0, 0); NVGcolor color = nvgRGBA(0, 0, 0, 0); NVGcolor borderColor = nvgRGBA(0, 0, 0, 0); + void draw(const DrawArgs &args) override; virtual void drawLight(const DrawArgs &args); virtual void drawHalo(const DrawArgs &args); diff --git a/include/app/MidiWidget.hpp b/include/app/MidiWidget.hpp index cb9c391f..707b2ff8 100644 --- a/include/app/MidiWidget.hpp +++ b/include/app/MidiWidget.hpp @@ -1,16 +1,10 @@ #pragma once #include "app/common.hpp" #include "app/LedDisplay.hpp" +#include "midi.hpp" namespace rack { - - -namespace midi { - struct Port; -} - - namespace app { diff --git a/include/app/ModuleLightWidget.hpp b/include/app/ModuleLightWidget.hpp index c82b9596..b702c2ea 100644 --- a/include/app/ModuleLightWidget.hpp +++ b/include/app/ModuleLightWidget.hpp @@ -14,6 +14,7 @@ Will access firstLightId, firstLightId + 1, etc. for each added color struct ModuleLightWidget : MultiLightWidget { engine::Module *module = NULL; int firstLightId; + void step() override; }; diff --git a/include/app/ModuleWidget.hpp b/include/app/ModuleWidget.hpp index a60dcb02..0127215d 100644 --- a/include/app/ModuleWidget.hpp +++ b/include/app/ModuleWidget.hpp @@ -4,6 +4,7 @@ #include "ui/Menu.hpp" #include "app/PortWidget.hpp" #include "app/ParamWidget.hpp" +#include "app/SvgPanel.hpp" #include "plugin/Model.hpp" #include "engine/Module.hpp" @@ -15,11 +16,11 @@ namespace app { /** Manages an engine::Module in the rack. */ struct ModuleWidget : widget::OpaqueWidget { plugin::Model *model = NULL; - /** Owns the module pointer */ + /** Owned. */ engine::Module *module = NULL; - widget::Widget *panel = NULL; - /** Note that the indexes of these vectors might not correspond with the indexes of `Module::params` etc. + SvgPanel *panel = NULL; + /** Note that the indexes of these vectors do not necessarily correspond with the indexes of `Module::params` etc. */ std::vector params; std::vector outputs; @@ -29,7 +30,7 @@ struct ModuleWidget : widget::OpaqueWidget { math::Vec oldPos; ModuleWidget(); - DEPRECATED ModuleWidget(engine::Module *module) { + DEPRECATED ModuleWidget(engine::Module *module) : ModuleWidget() { setModule(module); } ~ModuleWidget(); diff --git a/include/app/MultiLightWidget.hpp b/include/app/MultiLightWidget.hpp index 9411bbab..52f1fd7f 100644 --- a/include/app/MultiLightWidget.hpp +++ b/include/app/MultiLightWidget.hpp @@ -11,6 +11,7 @@ namespace app { struct MultiLightWidget : LightWidget { /** Colors of each value state */ std::vector baseColors; + void addBaseColor(NVGcolor baseColor); /** Sets the color to a linear combination of the baseColors with the given weights */ void setBrightnesses(const std::vector &brightnesses); diff --git a/include/app/Scene.hpp b/include/app/Scene.hpp index 11d86094..ecd953c9 100644 --- a/include/app/Scene.hpp +++ b/include/app/Scene.hpp @@ -17,13 +17,13 @@ struct Scene : widget::OpaqueWidget { MenuBar *menuBar; widget::Widget *moduleBrowser; + double lastAutoSaveTime = 0.0; + // Version checking bool checkVersion = true; bool checkedVersion = false; std::string latestVersion; - double lastAutoSaveTime = 0.0; - Scene(); ~Scene(); void step() override; diff --git a/include/app/SvgKnob.hpp b/include/app/SvgKnob.hpp index 9e5698da..3bb6d48e 100644 --- a/include/app/SvgKnob.hpp +++ b/include/app/SvgKnob.hpp @@ -18,7 +18,8 @@ struct SvgKnob : Knob { widget::TransformWidget *tw; widget::SvgWidget *sw; /** Angles in radians */ - float minAngle, maxAngle; + float minAngle = 0.f; + float maxAngle = M_PI; SvgKnob(); void setSvg(std::shared_ptr svg); diff --git a/include/app/common.hpp b/include/app/common.hpp index 433271f0..3695a86b 100644 --- a/include/app/common.hpp +++ b/include/app/common.hpp @@ -12,9 +12,9 @@ namespace rack { namespace app { -static const char APP_NAME[] = "VCV Rack"; -static const char APP_VERSION[] = TOSTRING(VERSION); -static const char API_URL[] = "https://api.vcvrack.com"; +extern const char APP_NAME[]; +extern const char APP_VERSION[]; +extern const char API_URL[]; static const float SVG_DPI = 75.0; static const float MM_PER_IN = 25.4; diff --git a/src/Core/Blank.cpp b/src/Core/Blank.cpp index 82c78904..eb864d83 100644 --- a/src/Core/Blank.cpp +++ b/src/Core/Blank.cpp @@ -93,13 +93,19 @@ struct BlankWidget : ModuleWidget { Widget *topRightScrew; Widget *bottomRightScrew; Widget *rightHandle; + BlankPanel *blankPanel; BlankWidget(Module *module) { setModule(module); box.size = Vec(RACK_GRID_WIDTH * 10, RACK_GRID_HEIGHT); - panel = new BlankPanel; - addChild(panel); + // Delete SvgPanel + removeChild(panel); + delete panel; + panel = NULL; + + blankPanel = new BlankPanel; + addChild(blankPanel); ModuleResizeHandle *leftHandle = new ModuleResizeHandle; ModuleResizeHandle *rightHandle = new ModuleResizeHandle; @@ -117,7 +123,7 @@ struct BlankWidget : ModuleWidget { } void step() override { - panel->box.size = box.size; + blankPanel->box.size = box.size; topRightScrew->box.pos.x = box.size.x - 30; bottomRightScrew->box.pos.x = box.size.x - 30; if (box.size.x < RACK_GRID_WIDTH * 6) { diff --git a/src/app/AudioWidget.cpp b/src/app/AudioWidget.cpp index e0994f75..8b56a20a 100644 --- a/src/app/AudioWidget.cpp +++ b/src/app/AudioWidget.cpp @@ -1,5 +1,4 @@ #include "app/AudioWidget.hpp" -#include "audio.hpp" #include "helpers.hpp" diff --git a/src/app/Knob.cpp b/src/app/Knob.cpp index 4c61d5a8..a3f7514c 100644 --- a/src/app/Knob.cpp +++ b/src/app/Knob.cpp @@ -43,6 +43,9 @@ void Knob::onDragStart(const event::DragStart &e) { } void Knob::onDragEnd(const event::DragEnd &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + APP->window->cursorUnlock(); if (paramQuantity) { @@ -66,6 +69,9 @@ void Knob::onDragEnd(const event::DragEnd &e) { } void Knob::onDragMove(const event::DragMove &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + if (paramQuantity) { float range; if (paramQuantity->isBounded()) { diff --git a/src/app/MidiWidget.cpp b/src/app/MidiWidget.cpp index 02d93b23..a4a1c1d4 100644 --- a/src/app/MidiWidget.cpp +++ b/src/app/MidiWidget.cpp @@ -1,5 +1,4 @@ #include "app/MidiWidget.hpp" -#include "midi.hpp" #include "helpers.hpp" diff --git a/src/app/ModuleWidget.cpp b/src/app/ModuleWidget.cpp index 4b6321f4..dbca8c7f 100644 --- a/src/app/ModuleWidget.cpp +++ b/src/app/ModuleWidget.cpp @@ -1,6 +1,5 @@ #include "app/ModuleWidget.hpp" #include "app/Scene.hpp" -#include "app/SvgPanel.hpp" #include "engine/Engine.hpp" #include "plugin/Plugin.hpp" #include "system.hpp" @@ -243,6 +242,9 @@ struct ModuleDeleteItem : ui::MenuItem { ModuleWidget::ModuleWidget() { box.size = math::Vec(0, RACK_GRID_HEIGHT); + + panel = new SvgPanel; + addChild(panel); } ModuleWidget::~ModuleWidget() { @@ -311,7 +313,7 @@ void ModuleWidget::onButton(const event::Button &e) { if (e.action == GLFW_PRESS && e.button == GLFW_MOUSE_BUTTON_RIGHT) { createContextMenu(); - e.consume(NULL); + e.consume(this); } } @@ -390,6 +392,9 @@ void ModuleWidget::onDragStart(const event::DragStart &e) { } void ModuleWidget::onDragEnd(const event::DragEnd &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + history::ComplexAction *h = APP->scene->rack->getModuleDragAction(); if (!h) { delete h; @@ -399,6 +404,9 @@ void ModuleWidget::onDragEnd(const event::DragEnd &e) { } void ModuleWidget::onDragMove(const event::DragMove &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + if (!settings::lockModules) { math::Vec pos = APP->scene->rack->mousePos.minus(dragPos); if ((APP->window->getMods() & RACK_MOD_MASK) == RACK_MOD_CTRL) @@ -416,18 +424,10 @@ void ModuleWidget::setModule(engine::Module *module) { } void ModuleWidget::setPanel(std::shared_ptr svg) { - // Remove old panel - if (panel) { - removeChild(panel); - delete panel; - panel = NULL; - } - - SvgPanel *svgPanel = new SvgPanel; - svgPanel->setBackground(svg); - addChild(svgPanel); - box.size.x = std::round(svgPanel->box.size.x / RACK_GRID_WIDTH) * RACK_GRID_WIDTH; - panel = svgPanel; + assert(panel); + panel->setBackground(svg); + // Set ModuleWidget size based on panel + box.size.x = std::round(panel->box.size.x / RACK_GRID_WIDTH) * RACK_GRID_WIDTH; } void ModuleWidget::addParam(ParamWidget *param) { diff --git a/src/app/PortWidget.cpp b/src/app/PortWidget.cpp index 14fcc6a9..3c356cce 100644 --- a/src/app/PortWidget.cpp +++ b/src/app/PortWidget.cpp @@ -74,7 +74,7 @@ void PortWidget::onButton(const event::Button &e) { delete cw; } - e.consume(NULL); + e.consume(this); } } @@ -135,6 +135,9 @@ void PortWidget::onDragStart(const event::DragStart &e) { } void PortWidget::onDragEnd(const event::DragEnd &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + CableWidget *cw = APP->scene->rack->releaseIncompleteCable(); if (cw->isComplete()) { APP->scene->rack->addCable(cw); @@ -150,6 +153,9 @@ void PortWidget::onDragEnd(const event::DragEnd &e) { } void PortWidget::onDragDrop(const event::DragDrop &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + // Reject ports if this is an input port and something is already plugged into it if (type == INPUT) { if (APP->scene->rack->getTopCable(this)) @@ -167,6 +173,9 @@ void PortWidget::onDragDrop(const event::DragDrop &e) { } void PortWidget::onDragEnter(const event::DragEnter &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + // Reject ports if this is an input port and something is already plugged into it if (type == INPUT) { if (APP->scene->rack->getTopCable(this)) @@ -183,6 +192,9 @@ void PortWidget::onDragEnter(const event::DragEnter &e) { } void PortWidget::onDragLeave(const event::DragLeave &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + PortWidget *originPort = dynamic_cast(e.origin); if (!originPort) return; diff --git a/src/app/Switch.cpp b/src/app/Switch.cpp index b92ea96f..c855dc11 100644 --- a/src/app/Switch.cpp +++ b/src/app/Switch.cpp @@ -67,6 +67,9 @@ void Switch::onDragStart(const event::DragStart &e) { } void Switch::onDragEnd(const event::DragEnd &e) { + if (e.button != GLFW_MOUSE_BUTTON_LEFT) + return; + if (momentary) { momentaryReleased = true; } diff --git a/src/app/common.cpp b/src/app/common.cpp new file mode 100644 index 00000000..e56db1ee --- /dev/null +++ b/src/app/common.cpp @@ -0,0 +1,15 @@ +#include "app/common.hpp" + + +namespace rack { +namespace app { + + +const char APP_NAME[] = "VCV Rack"; +const char APP_VERSION[] = TOSTRING(VERSION); +const char API_URL[] = "https://api.vcvrack.com"; + + + +} // namespace app +} // namespace rack From 0a71dde25e6a6b76bcb22568864629efdfa5a6c1 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Sun, 12 May 2019 16:14:33 -0400 Subject: [PATCH 27/41] alignedMalloc is unneeded. --- include/dsp/fft.hpp | 16 +--------------- src/dsp/minblep.cpp | 8 ++++---- 2 files changed, 5 insertions(+), 19 deletions(-) diff --git a/include/dsp/fft.hpp b/include/dsp/fft.hpp index 2aec33e1..0d0a1be7 100644 --- a/include/dsp/fft.hpp +++ b/include/dsp/fft.hpp @@ -7,24 +7,10 @@ namespace rack { namespace dsp { -/** Allocates an array to 64-byte boundaries. -Must call alignedFree() on the buffer to free. -*/ -template -T *alignedMalloc(size_t len) { - return (T*) pffft_aligned_malloc(len * sizeof(T)); -} - -template -void alignedFree(T *p) { - pffft_aligned_free(p); -} - - /** Real-valued FFT context. Wrapper for [PFFFT](https://bitbucket.org/jpommier/pffft/) `length` must be a multiple of 32. -Buffers must be aligned to 16-byte boundaries, e.g. with alignedMalloc(). +Buffers must be aligned to 16-byte boundaries. new[] and malloc() do this for you. */ struct RealFFT { PFFFT_Setup *setup; diff --git a/src/dsp/minblep.cpp b/src/dsp/minblep.cpp index 32cb34a4..0a3e5422 100644 --- a/src/dsp/minblep.cpp +++ b/src/dsp/minblep.cpp @@ -10,7 +10,7 @@ namespace dsp { void minBlepImpulse(int z, int o, float *output) { // Symmetric sinc array with `z` zero-crossings on each side int n = 2 * z * o; - float *x = alignedMalloc(n); + float *x = new float[n]; for (int i = 0; i < n; i++) { float p = math::rescale((float) i, 0.f, (float) (n - 1), (float) -z, (float) z); x[i] = sinc(p); @@ -20,7 +20,7 @@ void minBlepImpulse(int z, int o, float *output) { blackmanHarrisWindow(x, n); // Real cepstrum - float *fx = alignedMalloc(2*n); + float *fx = new float[2*n]; RealFFT rfft(n); rfft.rfft(x, fx); // fx = log(abs(fx)) @@ -73,8 +73,8 @@ void minBlepImpulse(int z, int o, float *output) { std::memcpy(output, x, n * sizeof(float)); // Cleanup - alignedFree(x); - alignedFree(fx); + delete[] x; + delete[] fx; } From babcc49a2af7c0f769badfc3c86bb69128ba93b1 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 13 May 2019 12:13:45 -0400 Subject: [PATCH 28/41] Attempt to link to glibc 2.23 for plugins. --- LICENSE-dist.txt | 25 + Makefile | 5 +- compile.mk | 9 +- include/force_link_glibc_2.23.h | 3727 +++++++++++++++++++++++++++++++ plugin.mk | 2 + 5 files changed, 3760 insertions(+), 8 deletions(-) create mode 100644 include/force_link_glibc_2.23.h diff --git a/LICENSE-dist.txt b/LICENSE-dist.txt index 38836a5a..57db3252 100644 --- a/LICENSE-dist.txt +++ b/LICENSE-dist.txt @@ -512,3 +512,28 @@ EXEMPLARY, OR CONSEQUENTIAL 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 WITH THE SOFTWARE. + + +# glibc_version_header + +MIT License + +Copyright (c) 2018 Tom Mason + +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. \ No newline at end of file diff --git a/Makefile b/Makefile index b991f189..2049d0bd 100644 --- a/Makefile +++ b/Makefile @@ -1,9 +1,8 @@ RACK_DIR ?= . -VERSION = 1.dev.$(shell git rev-parse --short HEAD) +VERSION := 1.dev.$(shell git rev-parse --short HEAD) FLAGS += -DVERSION=$(VERSION) -FLAGS += -Iinclude -FLAGS += -Idep/include -Idep/lib/libzip/include +FLAGS += -Iinclude -Idep/include include arch.mk diff --git a/compile.mk b/compile.mk index d21fe104..81c55f32 100644 --- a/compile.mk +++ b/compile.mk @@ -15,15 +15,13 @@ FLAGS += -g FLAGS += -O3 -march=nocona -funsafe-math-optimizations # Warnings FLAGS += -Wall -Wextra -Wno-unused-parameter - -ifneq ($(ARCH), mac) - CXXFLAGS += -Wsuggest-override -endif +# C++ standard CXXFLAGS += -std=c++11 - +# Architecture-independent flags ifdef ARCH_LIN FLAGS += -DARCH_LIN + CXXFLAGS += -Wsuggest-override endif ifdef ARCH_MAC FLAGS += -DARCH_MAC @@ -36,6 +34,7 @@ endif ifdef ARCH_WIN FLAGS += -DARCH_WIN FLAGS += -D_USE_MATH_DEFINES + CXXFLAGS += -Wsuggest-override endif CFLAGS += $(FLAGS) diff --git a/include/force_link_glibc_2.23.h b/include/force_link_glibc_2.23.h new file mode 100644 index 00000000..87b1c120 --- /dev/null +++ b/include/force_link_glibc_2.23.h @@ -0,0 +1,3727 @@ +#if !defined(SET_GLIBC_LINK_VERSIONS_HEADER) && !defined(__ASSEMBLER__) +#define SET_GLIBC_LINK_VERSIONS_HEADER +__asm__(".symver _Exit,_Exit@GLIBC_2.2.5"); +__asm__(".symver _IO_2_1_stderr_,_IO_2_1_stderr_@GLIBC_2.2.5"); +__asm__(".symver _IO_2_1_stdin_,_IO_2_1_stdin_@GLIBC_2.2.5"); +__asm__(".symver _IO_2_1_stdout_,_IO_2_1_stdout_@GLIBC_2.2.5"); +__asm__(".symver _IO_adjust_column,_IO_adjust_column@GLIBC_2.2.5"); +__asm__(".symver _IO_adjust_wcolumn,_IO_adjust_wcolumn@GLIBC_2.2.5"); +__asm__(".symver _IO_default_doallocate,_IO_default_doallocate@GLIBC_2.2.5"); +__asm__(".symver _IO_default_finish,_IO_default_finish@GLIBC_2.2.5"); +__asm__(".symver _IO_default_pbackfail,_IO_default_pbackfail@GLIBC_2.2.5"); +__asm__(".symver _IO_default_uflow,_IO_default_uflow@GLIBC_2.2.5"); +__asm__(".symver _IO_default_xsgetn,_IO_default_xsgetn@GLIBC_2.2.5"); +__asm__(".symver _IO_default_xsputn,_IO_default_xsputn@GLIBC_2.2.5"); +__asm__(".symver _IO_do_write,_IO_do_write@GLIBC_2.2.5"); +__asm__(".symver _IO_doallocbuf,_IO_doallocbuf@GLIBC_2.2.5"); +__asm__(".symver _IO_fclose,_IO_fclose@GLIBC_2.2.5"); +__asm__(".symver _IO_fdopen,_IO_fdopen@GLIBC_2.2.5"); +__asm__(".symver _IO_feof,_IO_feof@GLIBC_2.2.5"); +__asm__(".symver _IO_ferror,_IO_ferror@GLIBC_2.2.5"); +__asm__(".symver _IO_fflush,_IO_fflush@GLIBC_2.2.5"); +__asm__(".symver _IO_fgetpos,_IO_fgetpos@GLIBC_2.2.5"); +__asm__(".symver _IO_fgetpos64,_IO_fgetpos64@GLIBC_2.2.5"); +__asm__(".symver _IO_fgets,_IO_fgets@GLIBC_2.2.5"); +__asm__(".symver _IO_file_attach,_IO_file_attach@GLIBC_2.2.5"); +__asm__(".symver _IO_file_close,_IO_file_close@GLIBC_2.2.5"); +__asm__(".symver _IO_file_close_it,_IO_file_close_it@GLIBC_2.2.5"); +__asm__(".symver _IO_file_doallocate,_IO_file_doallocate@GLIBC_2.2.5"); +__asm__(".symver _IO_file_finish,_IO_file_finish@GLIBC_2.2.5"); +__asm__(".symver _IO_file_fopen,_IO_file_fopen@GLIBC_2.2.5"); +__asm__(".symver _IO_file_init,_IO_file_init@GLIBC_2.2.5"); +__asm__(".symver _IO_file_jumps,_IO_file_jumps@GLIBC_2.2.5"); +__asm__(".symver _IO_file_open,_IO_file_open@GLIBC_2.2.5"); +__asm__(".symver _IO_file_overflow,_IO_file_overflow@GLIBC_2.2.5"); +__asm__(".symver _IO_file_read,_IO_file_read@GLIBC_2.2.5"); +__asm__(".symver _IO_file_seek,_IO_file_seek@GLIBC_2.2.5"); +__asm__(".symver _IO_file_seekoff,_IO_file_seekoff@GLIBC_2.2.5"); +__asm__(".symver _IO_file_setbuf,_IO_file_setbuf@GLIBC_2.2.5"); +__asm__(".symver _IO_file_stat,_IO_file_stat@GLIBC_2.2.5"); +__asm__(".symver _IO_file_sync,_IO_file_sync@GLIBC_2.2.5"); +__asm__(".symver _IO_file_underflow,_IO_file_underflow@GLIBC_2.2.5"); +__asm__(".symver _IO_file_write,_IO_file_write@GLIBC_2.2.5"); +__asm__(".symver _IO_file_xsputn,_IO_file_xsputn@GLIBC_2.2.5"); +__asm__(".symver _IO_flockfile,_IO_flockfile@GLIBC_2.2.5"); +__asm__(".symver _IO_flush_all,_IO_flush_all@GLIBC_2.2.5"); +__asm__(".symver _IO_flush_all_linebuffered,_IO_flush_all_linebuffered@GLIBC_2.2.5"); +__asm__(".symver _IO_fopen,_IO_fopen@GLIBC_2.2.5"); +__asm__(".symver _IO_fprintf,_IO_fprintf@GLIBC_2.2.5"); +__asm__(".symver _IO_fputs,_IO_fputs@GLIBC_2.2.5"); +__asm__(".symver _IO_fread,_IO_fread@GLIBC_2.2.5"); +__asm__(".symver _IO_free_backup_area,_IO_free_backup_area@GLIBC_2.2.5"); +__asm__(".symver _IO_free_wbackup_area,_IO_free_wbackup_area@GLIBC_2.2.5"); +__asm__(".symver _IO_fsetpos,_IO_fsetpos@GLIBC_2.2.5"); +__asm__(".symver _IO_fsetpos64,_IO_fsetpos64@GLIBC_2.2.5"); +__asm__(".symver _IO_ftell,_IO_ftell@GLIBC_2.2.5"); +__asm__(".symver _IO_ftrylockfile,_IO_ftrylockfile@GLIBC_2.2.5"); +__asm__(".symver _IO_funlockfile,_IO_funlockfile@GLIBC_2.2.5"); +__asm__(".symver _IO_fwrite,_IO_fwrite@GLIBC_2.2.5"); +__asm__(".symver _IO_getc,_IO_getc@GLIBC_2.2.5"); +__asm__(".symver _IO_getline,_IO_getline@GLIBC_2.2.5"); +__asm__(".symver _IO_getline_info,_IO_getline_info@GLIBC_2.2.5"); +__asm__(".symver _IO_gets,_IO_gets@GLIBC_2.2.5"); +__asm__(".symver _IO_init,_IO_init@GLIBC_2.2.5"); +__asm__(".symver _IO_init_marker,_IO_init_marker@GLIBC_2.2.5"); +__asm__(".symver _IO_init_wmarker,_IO_init_wmarker@GLIBC_2.2.5"); +__asm__(".symver _IO_iter_begin,_IO_iter_begin@GLIBC_2.2.5"); +__asm__(".symver _IO_iter_end,_IO_iter_end@GLIBC_2.2.5"); +__asm__(".symver _IO_iter_file,_IO_iter_file@GLIBC_2.2.5"); +__asm__(".symver _IO_iter_next,_IO_iter_next@GLIBC_2.2.5"); +__asm__(".symver _IO_least_wmarker,_IO_least_wmarker@GLIBC_2.2.5"); +__asm__(".symver _IO_link_in,_IO_link_in@GLIBC_2.2.5"); +__asm__(".symver _IO_list_all,_IO_list_all@GLIBC_2.2.5"); +__asm__(".symver _IO_list_lock,_IO_list_lock@GLIBC_2.2.5"); +__asm__(".symver _IO_list_resetlock,_IO_list_resetlock@GLIBC_2.2.5"); +__asm__(".symver _IO_list_unlock,_IO_list_unlock@GLIBC_2.2.5"); +__asm__(".symver _IO_marker_delta,_IO_marker_delta@GLIBC_2.2.5"); +__asm__(".symver _IO_marker_difference,_IO_marker_difference@GLIBC_2.2.5"); +__asm__(".symver _IO_padn,_IO_padn@GLIBC_2.2.5"); +__asm__(".symver _IO_peekc_locked,_IO_peekc_locked@GLIBC_2.2.5"); +__asm__(".symver _IO_popen,_IO_popen@GLIBC_2.2.5"); +__asm__(".symver _IO_printf,_IO_printf@GLIBC_2.2.5"); +__asm__(".symver _IO_proc_close,_IO_proc_close@GLIBC_2.2.5"); +__asm__(".symver _IO_proc_open,_IO_proc_open@GLIBC_2.2.5"); +__asm__(".symver _IO_putc,_IO_putc@GLIBC_2.2.5"); +__asm__(".symver _IO_puts,_IO_puts@GLIBC_2.2.5"); +__asm__(".symver _IO_remove_marker,_IO_remove_marker@GLIBC_2.2.5"); +__asm__(".symver _IO_seekmark,_IO_seekmark@GLIBC_2.2.5"); +__asm__(".symver _IO_seekoff,_IO_seekoff@GLIBC_2.2.5"); +__asm__(".symver _IO_seekpos,_IO_seekpos@GLIBC_2.2.5"); +__asm__(".symver _IO_seekwmark,_IO_seekwmark@GLIBC_2.2.5"); +__asm__(".symver _IO_setb,_IO_setb@GLIBC_2.2.5"); +__asm__(".symver _IO_setbuffer,_IO_setbuffer@GLIBC_2.2.5"); +__asm__(".symver _IO_setvbuf,_IO_setvbuf@GLIBC_2.2.5"); +__asm__(".symver _IO_sgetn,_IO_sgetn@GLIBC_2.2.5"); +__asm__(".symver _IO_sprintf,_IO_sprintf@GLIBC_2.2.5"); +__asm__(".symver _IO_sputbackc,_IO_sputbackc@GLIBC_2.2.5"); +__asm__(".symver _IO_sputbackwc,_IO_sputbackwc@GLIBC_2.2.5"); +__asm__(".symver _IO_sscanf,_IO_sscanf@GLIBC_2.2.5"); +__asm__(".symver _IO_str_init_readonly,_IO_str_init_readonly@GLIBC_2.2.5"); +__asm__(".symver _IO_str_init_static,_IO_str_init_static@GLIBC_2.2.5"); +__asm__(".symver _IO_str_overflow,_IO_str_overflow@GLIBC_2.2.5"); +__asm__(".symver _IO_str_pbackfail,_IO_str_pbackfail@GLIBC_2.2.5"); +__asm__(".symver _IO_str_seekoff,_IO_str_seekoff@GLIBC_2.2.5"); +__asm__(".symver _IO_str_underflow,_IO_str_underflow@GLIBC_2.2.5"); +__asm__(".symver _IO_sungetc,_IO_sungetc@GLIBC_2.2.5"); +__asm__(".symver _IO_sungetwc,_IO_sungetwc@GLIBC_2.2.5"); +__asm__(".symver _IO_switch_to_get_mode,_IO_switch_to_get_mode@GLIBC_2.2.5"); +__asm__(".symver _IO_switch_to_main_wget_area,_IO_switch_to_main_wget_area@GLIBC_2.2.5"); +__asm__(".symver _IO_switch_to_wbackup_area,_IO_switch_to_wbackup_area@GLIBC_2.2.5"); +__asm__(".symver _IO_switch_to_wget_mode,_IO_switch_to_wget_mode@GLIBC_2.2.5"); +__asm__(".symver _IO_un_link,_IO_un_link@GLIBC_2.2.5"); +__asm__(".symver _IO_ungetc,_IO_ungetc@GLIBC_2.2.5"); +__asm__(".symver _IO_unsave_markers,_IO_unsave_markers@GLIBC_2.2.5"); +__asm__(".symver _IO_unsave_wmarkers,_IO_unsave_wmarkers@GLIBC_2.2.5"); +__asm__(".symver _IO_vfprintf,_IO_vfprintf@GLIBC_2.2.5"); +__asm__(".symver _IO_vfscanf,_IO_vfscanf@GLIBC_2.2.5"); +__asm__(".symver _IO_vsprintf,_IO_vsprintf@GLIBC_2.2.5"); +__asm__(".symver _IO_wdefault_doallocate,_IO_wdefault_doallocate@GLIBC_2.2.5"); +__asm__(".symver _IO_wdefault_finish,_IO_wdefault_finish@GLIBC_2.2.5"); +__asm__(".symver _IO_wdefault_pbackfail,_IO_wdefault_pbackfail@GLIBC_2.2.5"); +__asm__(".symver _IO_wdefault_uflow,_IO_wdefault_uflow@GLIBC_2.2.5"); +__asm__(".symver _IO_wdefault_xsgetn,_IO_wdefault_xsgetn@GLIBC_2.2.5"); +__asm__(".symver _IO_wdefault_xsputn,_IO_wdefault_xsputn@GLIBC_2.2.5"); +__asm__(".symver _IO_wdo_write,_IO_wdo_write@GLIBC_2.2.5"); +__asm__(".symver _IO_wdoallocbuf,_IO_wdoallocbuf@GLIBC_2.2.5"); +__asm__(".symver _IO_wfile_jumps,_IO_wfile_jumps@GLIBC_2.2.5"); +__asm__(".symver _IO_wfile_overflow,_IO_wfile_overflow@GLIBC_2.2.5"); +__asm__(".symver _IO_wfile_seekoff,_IO_wfile_seekoff@GLIBC_2.2.5"); +__asm__(".symver _IO_wfile_sync,_IO_wfile_sync@GLIBC_2.2.5"); +__asm__(".symver _IO_wfile_underflow,_IO_wfile_underflow@GLIBC_2.2.5"); +__asm__(".symver _IO_wfile_xsputn,_IO_wfile_xsputn@GLIBC_2.2.5"); +__asm__(".symver _IO_wmarker_delta,_IO_wmarker_delta@GLIBC_2.2.5"); +__asm__(".symver _IO_wsetb,_IO_wsetb@GLIBC_2.2.5"); +__asm__(".symver _LIB_VERSION,_LIB_VERSION@GLIBC_2.2.5"); +__asm__(".symver _ZGVbN2v_cos,_ZGVbN2v_cos@GLIBC_2.22"); +__asm__(".symver _ZGVbN2v_exp,_ZGVbN2v_exp@GLIBC_2.22"); +__asm__(".symver _ZGVbN2v_log,_ZGVbN2v_log@GLIBC_2.22"); +__asm__(".symver _ZGVbN2v_sin,_ZGVbN2v_sin@GLIBC_2.22"); +__asm__(".symver _ZGVbN2vv_pow,_ZGVbN2vv_pow@GLIBC_2.22"); +__asm__(".symver _ZGVbN2vvv_sincos,_ZGVbN2vvv_sincos@GLIBC_2.22"); +__asm__(".symver _ZGVbN4v_cosf,_ZGVbN4v_cosf@GLIBC_2.22"); +__asm__(".symver _ZGVbN4v_expf,_ZGVbN4v_expf@GLIBC_2.22"); +__asm__(".symver _ZGVbN4v_logf,_ZGVbN4v_logf@GLIBC_2.22"); +__asm__(".symver _ZGVbN4v_sinf,_ZGVbN4v_sinf@GLIBC_2.22"); +__asm__(".symver _ZGVbN4vv_powf,_ZGVbN4vv_powf@GLIBC_2.22"); +__asm__(".symver _ZGVbN4vvv_sincosf,_ZGVbN4vvv_sincosf@GLIBC_2.22"); +__asm__(".symver _ZGVcN4v_cos,_ZGVcN4v_cos@GLIBC_2.22"); +__asm__(".symver _ZGVcN4v_exp,_ZGVcN4v_exp@GLIBC_2.22"); +__asm__(".symver _ZGVcN4v_log,_ZGVcN4v_log@GLIBC_2.22"); +__asm__(".symver _ZGVcN4v_sin,_ZGVcN4v_sin@GLIBC_2.22"); +__asm__(".symver _ZGVcN4vv_pow,_ZGVcN4vv_pow@GLIBC_2.22"); +__asm__(".symver _ZGVcN4vvv_sincos,_ZGVcN4vvv_sincos@GLIBC_2.22"); +__asm__(".symver _ZGVcN8v_cosf,_ZGVcN8v_cosf@GLIBC_2.22"); +__asm__(".symver _ZGVcN8v_expf,_ZGVcN8v_expf@GLIBC_2.22"); +__asm__(".symver _ZGVcN8v_logf,_ZGVcN8v_logf@GLIBC_2.22"); +__asm__(".symver _ZGVcN8v_sinf,_ZGVcN8v_sinf@GLIBC_2.22"); +__asm__(".symver _ZGVcN8vv_powf,_ZGVcN8vv_powf@GLIBC_2.22"); +__asm__(".symver _ZGVcN8vvv_sincosf,_ZGVcN8vvv_sincosf@GLIBC_2.22"); +__asm__(".symver _ZGVdN4v_cos,_ZGVdN4v_cos@GLIBC_2.22"); +__asm__(".symver _ZGVdN4v_exp,_ZGVdN4v_exp@GLIBC_2.22"); +__asm__(".symver _ZGVdN4v_log,_ZGVdN4v_log@GLIBC_2.22"); +__asm__(".symver _ZGVdN4v_sin,_ZGVdN4v_sin@GLIBC_2.22"); +__asm__(".symver _ZGVdN4vv_pow,_ZGVdN4vv_pow@GLIBC_2.22"); +__asm__(".symver _ZGVdN4vvv_sincos,_ZGVdN4vvv_sincos@GLIBC_2.22"); +__asm__(".symver _ZGVdN8v_cosf,_ZGVdN8v_cosf@GLIBC_2.22"); +__asm__(".symver _ZGVdN8v_expf,_ZGVdN8v_expf@GLIBC_2.22"); +__asm__(".symver _ZGVdN8v_logf,_ZGVdN8v_logf@GLIBC_2.22"); +__asm__(".symver _ZGVdN8v_sinf,_ZGVdN8v_sinf@GLIBC_2.22"); +__asm__(".symver _ZGVdN8vv_powf,_ZGVdN8vv_powf@GLIBC_2.22"); +__asm__(".symver _ZGVdN8vvv_sincosf,_ZGVdN8vvv_sincosf@GLIBC_2.22"); +__asm__(".symver _ZGVeN16v_cosf,_ZGVeN16v_cosf@GLIBC_2.22"); +__asm__(".symver _ZGVeN16v_expf,_ZGVeN16v_expf@GLIBC_2.22"); +__asm__(".symver _ZGVeN16v_logf,_ZGVeN16v_logf@GLIBC_2.22"); +__asm__(".symver _ZGVeN16v_sinf,_ZGVeN16v_sinf@GLIBC_2.22"); +__asm__(".symver _ZGVeN16vv_powf,_ZGVeN16vv_powf@GLIBC_2.22"); +__asm__(".symver _ZGVeN16vvv_sincosf,_ZGVeN16vvv_sincosf@GLIBC_2.22"); +__asm__(".symver _ZGVeN8v_cos,_ZGVeN8v_cos@GLIBC_2.22"); +__asm__(".symver _ZGVeN8v_exp,_ZGVeN8v_exp@GLIBC_2.22"); +__asm__(".symver _ZGVeN8v_log,_ZGVeN8v_log@GLIBC_2.22"); +__asm__(".symver _ZGVeN8v_sin,_ZGVeN8v_sin@GLIBC_2.22"); +__asm__(".symver _ZGVeN8vv_pow,_ZGVeN8vv_pow@GLIBC_2.22"); +__asm__(".symver _ZGVeN8vvv_sincos,_ZGVeN8vvv_sincos@GLIBC_2.22"); +__asm__(".symver __acos_finite,__acos_finite@GLIBC_2.15"); +__asm__(".symver __acosf_finite,__acosf_finite@GLIBC_2.15"); +__asm__(".symver __acosh_finite,__acosh_finite@GLIBC_2.15"); +__asm__(".symver __acoshf_finite,__acoshf_finite@GLIBC_2.15"); +__asm__(".symver __acoshl_finite,__acoshl_finite@GLIBC_2.15"); +__asm__(".symver __acosl_finite,__acosl_finite@GLIBC_2.15"); +__asm__(".symver __adjtimex,__adjtimex@GLIBC_2.2.5"); +__asm__(".symver __after_morecore_hook,__after_morecore_hook@GLIBC_2.2.5"); +__asm__(".symver __arch_prctl,__arch_prctl@GLIBC_2.2.5"); +__asm__(".symver __argz_count,__argz_count@GLIBC_2.2.5"); +__asm__(".symver __argz_next,__argz_next@GLIBC_2.2.5"); +__asm__(".symver __argz_stringify,__argz_stringify@GLIBC_2.2.5"); +__asm__(".symver __asin_finite,__asin_finite@GLIBC_2.15"); +__asm__(".symver __asinf_finite,__asinf_finite@GLIBC_2.15"); +__asm__(".symver __asinl_finite,__asinl_finite@GLIBC_2.15"); +__asm__(".symver __asprintf,__asprintf@GLIBC_2.2.5"); +__asm__(".symver __asprintf_chk,__asprintf_chk@GLIBC_2.8"); +__asm__(".symver __assert,__assert@GLIBC_2.2.5"); +__asm__(".symver __assert_fail,__assert_fail@GLIBC_2.2.5"); +__asm__(".symver __assert_perror_fail,__assert_perror_fail@GLIBC_2.2.5"); +__asm__(".symver __atan2_finite,__atan2_finite@GLIBC_2.15"); +__asm__(".symver __atan2f_finite,__atan2f_finite@GLIBC_2.15"); +__asm__(".symver __atan2l_finite,__atan2l_finite@GLIBC_2.15"); +__asm__(".symver __atanh_finite,__atanh_finite@GLIBC_2.15"); +__asm__(".symver __atanhf_finite,__atanhf_finite@GLIBC_2.15"); +__asm__(".symver __atanhl_finite,__atanhl_finite@GLIBC_2.15"); +__asm__(".symver __b64_ntop,__b64_ntop@GLIBC_2.2.5"); +__asm__(".symver __b64_pton,__b64_pton@GLIBC_2.2.5"); +__asm__(".symver __backtrace,__backtrace@GLIBC_2.2.5"); +__asm__(".symver __backtrace_symbols,__backtrace_symbols@GLIBC_2.2.5"); +__asm__(".symver __backtrace_symbols_fd,__backtrace_symbols_fd@GLIBC_2.2.5"); +__asm__(".symver __bsd_getpgrp,__bsd_getpgrp@GLIBC_2.2.5"); +__asm__(".symver __bzero,__bzero@GLIBC_2.2.5"); +__asm__(".symver __check_rhosts_file,__check_rhosts_file@GLIBC_2.2.5"); +__asm__(".symver __chk_fail,__chk_fail@GLIBC_2.3.4"); +__asm__(".symver __clog10,__clog10@GLIBC_2.2.5"); +__asm__(".symver __clog10f,__clog10f@GLIBC_2.2.5"); +__asm__(".symver __clog10l,__clog10l@GLIBC_2.2.5"); +__asm__(".symver __clone,__clone@GLIBC_2.2.5"); +__asm__(".symver __close,__close@GLIBC_2.2.5"); +__asm__(".symver __cmsg_nxthdr,__cmsg_nxthdr@GLIBC_2.2.5"); +__asm__(".symver __confstr_chk,__confstr_chk@GLIBC_2.4"); +__asm__(".symver __connect,__connect@GLIBC_2.2.5"); +__asm__(".symver __cosh_finite,__cosh_finite@GLIBC_2.15"); +__asm__(".symver __coshf_finite,__coshf_finite@GLIBC_2.15"); +__asm__(".symver __coshl_finite,__coshl_finite@GLIBC_2.15"); +__asm__(".symver __ctype_b_loc,__ctype_b_loc@GLIBC_2.3"); +__asm__(".symver __ctype_get_mb_cur_max,__ctype_get_mb_cur_max@GLIBC_2.2.5"); +__asm__(".symver __ctype_tolower_loc,__ctype_tolower_loc@GLIBC_2.3"); +__asm__(".symver __ctype_toupper_loc,__ctype_toupper_loc@GLIBC_2.3"); +__asm__(".symver __curbrk,__curbrk@GLIBC_2.2.5"); +__asm__(".symver __cxa_at_quick_exit,__cxa_at_quick_exit@GLIBC_2.10"); +__asm__(".symver __cxa_atexit,__cxa_atexit@GLIBC_2.2.5"); +__asm__(".symver __cxa_finalize,__cxa_finalize@GLIBC_2.2.5"); +__asm__(".symver __cxa_thread_atexit_impl,__cxa_thread_atexit_impl@GLIBC_2.18"); +__asm__(".symver __cyg_profile_func_enter,__cyg_profile_func_enter@GLIBC_2.2.5"); +__asm__(".symver __cyg_profile_func_exit,__cyg_profile_func_exit@GLIBC_2.2.5"); +__asm__(".symver __daylight,__daylight@GLIBC_2.2.5"); +__asm__(".symver __dcgettext,__dcgettext@GLIBC_2.2.5"); +__asm__(".symver __default_morecore,__default_morecore@GLIBC_2.2.5"); +__asm__(".symver __dgettext,__dgettext@GLIBC_2.2.5"); +__asm__(".symver __dn_comp,__dn_comp@GLIBC_2.2.5"); +__asm__(".symver __dn_count_labels,__dn_count_labels@GLIBC_2.2.5"); +__asm__(".symver __dn_expand,__dn_expand@GLIBC_2.2.5"); +__asm__(".symver __dn_skipname,__dn_skipname@GLIBC_2.2.5"); +__asm__(".symver __dprintf_chk,__dprintf_chk@GLIBC_2.8"); +__asm__(".symver __dup2,__dup2@GLIBC_2.2.5"); +__asm__(".symver __duplocale,__duplocale@GLIBC_2.2.5"); +__asm__(".symver __endmntent,__endmntent@GLIBC_2.2.5"); +__asm__(".symver __environ,__environ@GLIBC_2.2.5"); +__asm__(".symver __errno_location,__errno_location@GLIBC_2.2.5"); +__asm__(".symver __exp10_finite,__exp10_finite@GLIBC_2.15"); +__asm__(".symver __exp10f_finite,__exp10f_finite@GLIBC_2.15"); +__asm__(".symver __exp10l_finite,__exp10l_finite@GLIBC_2.15"); +__asm__(".symver __exp2_finite,__exp2_finite@GLIBC_2.15"); +__asm__(".symver __exp2f_finite,__exp2f_finite@GLIBC_2.15"); +__asm__(".symver __exp2l_finite,__exp2l_finite@GLIBC_2.15"); +__asm__(".symver __exp_finite,__exp_finite@GLIBC_2.15"); +__asm__(".symver __expf_finite,__expf_finite@GLIBC_2.15"); +__asm__(".symver __expl_finite,__expl_finite@GLIBC_2.15"); +__asm__(".symver __fbufsize,__fbufsize@GLIBC_2.2.5"); +__asm__(".symver __fcntl,__fcntl@GLIBC_2.2.5"); +__asm__(".symver __fdelt_chk,__fdelt_chk@GLIBC_2.15"); +__asm__(".symver __fdelt_warn,__fdelt_warn@GLIBC_2.15"); +__asm__(".symver __fentry__,__fentry__@GLIBC_2.13"); +__asm__(".symver __ffs,__ffs@GLIBC_2.2.5"); +__asm__(".symver __fgets_chk,__fgets_chk@GLIBC_2.4"); +__asm__(".symver __fgets_unlocked_chk,__fgets_unlocked_chk@GLIBC_2.4"); +__asm__(".symver __fgetws_chk,__fgetws_chk@GLIBC_2.4"); +__asm__(".symver __fgetws_unlocked_chk,__fgetws_unlocked_chk@GLIBC_2.4"); +__asm__(".symver __finite,__finite@GLIBC_2.2.5"); +__asm__(".symver __finitef,__finitef@GLIBC_2.2.5"); +__asm__(".symver __finitel,__finitel@GLIBC_2.2.5"); +__asm__(".symver __flbf,__flbf@GLIBC_2.2.5"); +__asm__(".symver __fmod_finite,__fmod_finite@GLIBC_2.15"); +__asm__(".symver __fmodf_finite,__fmodf_finite@GLIBC_2.15"); +__asm__(".symver __fmodl_finite,__fmodl_finite@GLIBC_2.15"); +__asm__(".symver __fork,__fork@GLIBC_2.2.5"); +__asm__(".symver __fp_nquery,__fp_nquery@GLIBC_2.2.5"); +__asm__(".symver __fp_query,__fp_query@GLIBC_2.2.5"); +__asm__(".symver __fp_resstat,__fp_resstat@GLIBC_2.2.5"); +__asm__(".symver __fpclassify,__fpclassify@GLIBC_2.2.5"); +__asm__(".symver __fpclassifyf,__fpclassifyf@GLIBC_2.2.5"); +__asm__(".symver __fpclassifyl,__fpclassifyl@GLIBC_2.2.5"); +__asm__(".symver __fpending,__fpending@GLIBC_2.2.5"); +__asm__(".symver __fprintf_chk,__fprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __fpu_control,__fpu_control@GLIBC_2.2.5"); +__asm__(".symver __fpurge,__fpurge@GLIBC_2.2.5"); +__asm__(".symver __fread_chk,__fread_chk@GLIBC_2.7"); +__asm__(".symver __fread_unlocked_chk,__fread_unlocked_chk@GLIBC_2.7"); +__asm__(".symver __freadable,__freadable@GLIBC_2.2.5"); +__asm__(".symver __freading,__freading@GLIBC_2.2.5"); +__asm__(".symver __free_fdresult,__free_fdresult@GLIBC_2.2.5"); +__asm__(".symver __free_hook,__free_hook@GLIBC_2.2.5"); +__asm__(".symver __freelocale,__freelocale@GLIBC_2.2.5"); +__asm__(".symver __fsetlocking,__fsetlocking@GLIBC_2.2.5"); +__asm__(".symver __fwprintf_chk,__fwprintf_chk@GLIBC_2.4"); +__asm__(".symver __fwritable,__fwritable@GLIBC_2.2.5"); +__asm__(".symver __fwriting,__fwriting@GLIBC_2.2.5"); +__asm__(".symver __fxstat,__fxstat@GLIBC_2.2.5"); +__asm__(".symver __fxstat64,__fxstat64@GLIBC_2.2.5"); +__asm__(".symver __fxstatat,__fxstatat@GLIBC_2.4"); +__asm__(".symver __fxstatat64,__fxstatat64@GLIBC_2.4"); +__asm__(".symver __gamma_r_finite,__gamma_r_finite@GLIBC_2.15"); +__asm__(".symver __gammaf_r_finite,__gammaf_r_finite@GLIBC_2.15"); +__asm__(".symver __gammal_r_finite,__gammal_r_finite@GLIBC_2.15"); +__asm__(".symver __getauxval,__getauxval@GLIBC_2.16"); +__asm__(".symver __getcwd_chk,__getcwd_chk@GLIBC_2.4"); +__asm__(".symver __getdelim,__getdelim@GLIBC_2.2.5"); +__asm__(".symver __getdomainname_chk,__getdomainname_chk@GLIBC_2.4"); +__asm__(".symver __getgroups_chk,__getgroups_chk@GLIBC_2.4"); +__asm__(".symver __gethostname_chk,__gethostname_chk@GLIBC_2.4"); +__asm__(".symver __getlogin_r_chk,__getlogin_r_chk@GLIBC_2.4"); +__asm__(".symver __getmntent_r,__getmntent_r@GLIBC_2.2.5"); +__asm__(".symver __getpagesize,__getpagesize@GLIBC_2.2.5"); +__asm__(".symver __getpgid,__getpgid@GLIBC_2.2.5"); +__asm__(".symver __getpid,__getpid@GLIBC_2.2.5"); +__asm__(".symver __gets_chk,__gets_chk@GLIBC_2.3.4"); +__asm__(".symver __gettimeofday,__gettimeofday@GLIBC_2.2.5"); +__asm__(".symver __getwd_chk,__getwd_chk@GLIBC_2.4"); +__asm__(".symver __gmtime_r,__gmtime_r@GLIBC_2.2.5"); +__asm__(".symver __h_errno_location,__h_errno_location@GLIBC_2.2.5"); +__asm__(".symver __hostalias,__hostalias@GLIBC_2.2.5"); +__asm__(".symver __hypot_finite,__hypot_finite@GLIBC_2.15"); +__asm__(".symver __hypotf_finite,__hypotf_finite@GLIBC_2.15"); +__asm__(".symver __hypotl_finite,__hypotl_finite@GLIBC_2.15"); +__asm__(".symver __isalnum_l,__isalnum_l@GLIBC_2.2.5"); +__asm__(".symver __isalpha_l,__isalpha_l@GLIBC_2.2.5"); +__asm__(".symver __isascii_l,__isascii_l@GLIBC_2.2.5"); +__asm__(".symver __isblank_l,__isblank_l@GLIBC_2.2.5"); +__asm__(".symver __iscntrl_l,__iscntrl_l@GLIBC_2.2.5"); +__asm__(".symver __isctype,__isctype@GLIBC_2.3"); +__asm__(".symver __isdigit_l,__isdigit_l@GLIBC_2.2.5"); +__asm__(".symver __isgraph_l,__isgraph_l@GLIBC_2.2.5"); +__asm__(".symver __isinf,__isinf@GLIBC_2.2.5"); +__asm__(".symver __isinff,__isinff@GLIBC_2.2.5"); +__asm__(".symver __isinfl,__isinfl@GLIBC_2.2.5"); +__asm__(".symver __islower_l,__islower_l@GLIBC_2.2.5"); +__asm__(".symver __isnan,__isnan@GLIBC_2.2.5"); +__asm__(".symver __isnanf,__isnanf@GLIBC_2.2.5"); +__asm__(".symver __isnanl,__isnanl@GLIBC_2.2.5"); +__asm__(".symver __isoc99_fscanf,__isoc99_fscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_fwscanf,__isoc99_fwscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_scanf,__isoc99_scanf@GLIBC_2.7"); +__asm__(".symver __isoc99_sscanf,__isoc99_sscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_swscanf,__isoc99_swscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_vfscanf,__isoc99_vfscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_vfwscanf,__isoc99_vfwscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_vscanf,__isoc99_vscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_vsscanf,__isoc99_vsscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_vswscanf,__isoc99_vswscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_vwscanf,__isoc99_vwscanf@GLIBC_2.7"); +__asm__(".symver __isoc99_wscanf,__isoc99_wscanf@GLIBC_2.7"); +__asm__(".symver __isprint_l,__isprint_l@GLIBC_2.2.5"); +__asm__(".symver __ispunct_l,__ispunct_l@GLIBC_2.2.5"); +__asm__(".symver __issignaling,__issignaling@GLIBC_2.18"); +__asm__(".symver __issignalingf,__issignalingf@GLIBC_2.18"); +__asm__(".symver __issignalingl,__issignalingl@GLIBC_2.18"); +__asm__(".symver __isspace_l,__isspace_l@GLIBC_2.2.5"); +__asm__(".symver __isupper_l,__isupper_l@GLIBC_2.2.5"); +__asm__(".symver __iswalnum_l,__iswalnum_l@GLIBC_2.2.5"); +__asm__(".symver __iswalpha_l,__iswalpha_l@GLIBC_2.2.5"); +__asm__(".symver __iswblank_l,__iswblank_l@GLIBC_2.2.5"); +__asm__(".symver __iswcntrl_l,__iswcntrl_l@GLIBC_2.2.5"); +__asm__(".symver __iswctype,__iswctype@GLIBC_2.2.5"); +__asm__(".symver __iswctype_l,__iswctype_l@GLIBC_2.2.5"); +__asm__(".symver __iswdigit_l,__iswdigit_l@GLIBC_2.2.5"); +__asm__(".symver __iswgraph_l,__iswgraph_l@GLIBC_2.2.5"); +__asm__(".symver __iswlower_l,__iswlower_l@GLIBC_2.2.5"); +__asm__(".symver __iswprint_l,__iswprint_l@GLIBC_2.2.5"); +__asm__(".symver __iswpunct_l,__iswpunct_l@GLIBC_2.2.5"); +__asm__(".symver __iswspace_l,__iswspace_l@GLIBC_2.2.5"); +__asm__(".symver __iswupper_l,__iswupper_l@GLIBC_2.2.5"); +__asm__(".symver __iswxdigit_l,__iswxdigit_l@GLIBC_2.2.5"); +__asm__(".symver __isxdigit_l,__isxdigit_l@GLIBC_2.2.5"); +__asm__(".symver __ivaliduser,__ivaliduser@GLIBC_2.2.5"); +__asm__(".symver __j0_finite,__j0_finite@GLIBC_2.15"); +__asm__(".symver __j0f_finite,__j0f_finite@GLIBC_2.15"); +__asm__(".symver __j0l_finite,__j0l_finite@GLIBC_2.15"); +__asm__(".symver __j1_finite,__j1_finite@GLIBC_2.15"); +__asm__(".symver __j1f_finite,__j1f_finite@GLIBC_2.15"); +__asm__(".symver __j1l_finite,__j1l_finite@GLIBC_2.15"); +__asm__(".symver __jn_finite,__jn_finite@GLIBC_2.15"); +__asm__(".symver __jnf_finite,__jnf_finite@GLIBC_2.15"); +__asm__(".symver __jnl_finite,__jnl_finite@GLIBC_2.15"); +__asm__(".symver __key_decryptsession_pk_LOCAL,__key_decryptsession_pk_LOCAL@GLIBC_2.2.5"); +__asm__(".symver __key_encryptsession_pk_LOCAL,__key_encryptsession_pk_LOCAL@GLIBC_2.2.5"); +__asm__(".symver __key_gendes_LOCAL,__key_gendes_LOCAL@GLIBC_2.2.5"); +__asm__(".symver __lgamma_r_finite,__lgamma_r_finite@GLIBC_2.15"); +__asm__(".symver __lgammaf_r_finite,__lgammaf_r_finite@GLIBC_2.15"); +__asm__(".symver __lgammal_r_finite,__lgammal_r_finite@GLIBC_2.15"); +__asm__(".symver __libc_allocate_rtsig,__libc_allocate_rtsig@GLIBC_2.2.5"); +__asm__(".symver __libc_calloc,__libc_calloc@GLIBC_2.2.5"); +__asm__(".symver __libc_current_sigrtmax,__libc_current_sigrtmax@GLIBC_2.2.5"); +__asm__(".symver __libc_current_sigrtmin,__libc_current_sigrtmin@GLIBC_2.2.5"); +__asm__(".symver __libc_free,__libc_free@GLIBC_2.2.5"); +__asm__(".symver __libc_freeres,__libc_freeres@GLIBC_2.2.5"); +__asm__(".symver __libc_init_first,__libc_init_first@GLIBC_2.2.5"); +__asm__(".symver __libc_mallinfo,__libc_mallinfo@GLIBC_2.2.5"); +__asm__(".symver __libc_malloc,__libc_malloc@GLIBC_2.2.5"); +__asm__(".symver __libc_mallopt,__libc_mallopt@GLIBC_2.2.5"); +__asm__(".symver __libc_memalign,__libc_memalign@GLIBC_2.2.5"); +__asm__(".symver __libc_pvalloc,__libc_pvalloc@GLIBC_2.2.5"); +__asm__(".symver __libc_realloc,__libc_realloc@GLIBC_2.2.5"); +__asm__(".symver __libc_sa_len,__libc_sa_len@GLIBC_2.2.5"); +__asm__(".symver __libc_stack_end,__libc_stack_end@GLIBC_2.2.5"); +__asm__(".symver __libc_start_main,__libc_start_main@GLIBC_2.2.5"); +__asm__(".symver __libc_valloc,__libc_valloc@GLIBC_2.2.5"); +__asm__(".symver __loc_aton,__loc_aton@GLIBC_2.2.5"); +__asm__(".symver __loc_ntoa,__loc_ntoa@GLIBC_2.2.5"); +__asm__(".symver __log10_finite,__log10_finite@GLIBC_2.15"); +__asm__(".symver __log10f_finite,__log10f_finite@GLIBC_2.15"); +__asm__(".symver __log10l_finite,__log10l_finite@GLIBC_2.15"); +__asm__(".symver __log2_finite,__log2_finite@GLIBC_2.15"); +__asm__(".symver __log2f_finite,__log2f_finite@GLIBC_2.15"); +__asm__(".symver __log2l_finite,__log2l_finite@GLIBC_2.15"); +__asm__(".symver __log_finite,__log_finite@GLIBC_2.15"); +__asm__(".symver __logf_finite,__logf_finite@GLIBC_2.15"); +__asm__(".symver __logl_finite,__logl_finite@GLIBC_2.15"); +__asm__(".symver __longjmp_chk,__longjmp_chk@GLIBC_2.11"); +__asm__(".symver __lseek,__lseek@GLIBC_2.2.5"); +__asm__(".symver __lxstat,__lxstat@GLIBC_2.2.5"); +__asm__(".symver __lxstat64,__lxstat64@GLIBC_2.2.5"); +__asm__(".symver __malloc_hook,__malloc_hook@GLIBC_2.2.5"); +__asm__(".symver __malloc_initialize_hook,__malloc_initialize_hook@GLIBC_2.2.5"); +__asm__(".symver __mbrlen,__mbrlen@GLIBC_2.2.5"); +__asm__(".symver __mbrtowc,__mbrtowc@GLIBC_2.2.5"); +__asm__(".symver __mbsnrtowcs_chk,__mbsnrtowcs_chk@GLIBC_2.4"); +__asm__(".symver __mbsrtowcs_chk,__mbsrtowcs_chk@GLIBC_2.4"); +__asm__(".symver __mbstowcs_chk,__mbstowcs_chk@GLIBC_2.4"); +__asm__(".symver __memalign_hook,__memalign_hook@GLIBC_2.2.5"); +__asm__(".symver __memcpy_chk,__memcpy_chk@GLIBC_2.3.4"); +__asm__(".symver __memmove_chk,__memmove_chk@GLIBC_2.3.4"); +__asm__(".symver __mempcpy,__mempcpy@GLIBC_2.2.5"); +__asm__(".symver __mempcpy_chk,__mempcpy_chk@GLIBC_2.3.4"); +__asm__(".symver __mempcpy_small,__mempcpy_small@GLIBC_2.2.5"); +__asm__(".symver __memset_chk,__memset_chk@GLIBC_2.3.4"); +__asm__(".symver __monstartup,__monstartup@GLIBC_2.2.5"); +__asm__(".symver __morecore,__morecore@GLIBC_2.2.5"); +__asm__(".symver __mq_open_2,__mq_open_2@GLIBC_2.7"); +__asm__(".symver __nanosleep,__nanosleep@GLIBC_2.2.6"); +__asm__(".symver __newlocale,__newlocale@GLIBC_2.2.5"); +__asm__(".symver __nis_default_access,__nis_default_access@GLIBC_2.2.5"); +__asm__(".symver __nis_default_group,__nis_default_group@GLIBC_2.2.5"); +__asm__(".symver __nis_default_owner,__nis_default_owner@GLIBC_2.2.5"); +__asm__(".symver __nis_default_ttl,__nis_default_ttl@GLIBC_2.2.5"); +__asm__(".symver __nis_finddirectory,__nis_finddirectory@GLIBC_2.2.5"); +__asm__(".symver __nis_hash,__nis_hash@GLIBC_2.2.5"); +__asm__(".symver __nisbind_connect,__nisbind_connect@GLIBC_2.2.5"); +__asm__(".symver __nisbind_create,__nisbind_create@GLIBC_2.2.5"); +__asm__(".symver __nisbind_destroy,__nisbind_destroy@GLIBC_2.2.5"); +__asm__(".symver __nisbind_next,__nisbind_next@GLIBC_2.2.5"); +__asm__(".symver __nl_langinfo_l,__nl_langinfo_l@GLIBC_2.2.5"); +__asm__(".symver __nss_configure_lookup,__nss_configure_lookup@GLIBC_2.2.5"); +__asm__(".symver __nss_database_lookup,__nss_database_lookup@GLIBC_2.2.5"); +__asm__(".symver __nss_group_lookup,__nss_group_lookup@GLIBC_2.2.5"); +__asm__(".symver __nss_hostname_digits_dots,__nss_hostname_digits_dots@GLIBC_2.2.5"); +__asm__(".symver __nss_hosts_lookup,__nss_hosts_lookup@GLIBC_2.2.5"); +__asm__(".symver __nss_next,__nss_next@GLIBC_2.2.5"); +__asm__(".symver __nss_passwd_lookup,__nss_passwd_lookup@GLIBC_2.2.5"); +__asm__(".symver __obstack_printf_chk,__obstack_printf_chk@GLIBC_2.8"); +__asm__(".symver __obstack_vprintf_chk,__obstack_vprintf_chk@GLIBC_2.8"); +__asm__(".symver __open,__open@GLIBC_2.2.5"); +__asm__(".symver __open64,__open64@GLIBC_2.2.5"); +__asm__(".symver __open64_2,__open64_2@GLIBC_2.7"); +__asm__(".symver __open_2,__open_2@GLIBC_2.7"); +__asm__(".symver __openat64_2,__openat64_2@GLIBC_2.7"); +__asm__(".symver __openat_2,__openat_2@GLIBC_2.7"); +__asm__(".symver __overflow,__overflow@GLIBC_2.2.5"); +__asm__(".symver __p_cdname,__p_cdname@GLIBC_2.2.5"); +__asm__(".symver __p_cdnname,__p_cdnname@GLIBC_2.2.5"); +__asm__(".symver __p_class,__p_class@GLIBC_2.2.5"); +__asm__(".symver __p_class_syms,__p_class_syms@GLIBC_2.2.5"); +__asm__(".symver __p_fqname,__p_fqname@GLIBC_2.2.5"); +__asm__(".symver __p_fqnname,__p_fqnname@GLIBC_2.2.5"); +__asm__(".symver __p_option,__p_option@GLIBC_2.2.5"); +__asm__(".symver __p_query,__p_query@GLIBC_2.2.5"); +__asm__(".symver __p_rcode,__p_rcode@GLIBC_2.3.2"); +__asm__(".symver __p_secstodate,__p_secstodate@GLIBC_2.2.5"); +__asm__(".symver __p_time,__p_time@GLIBC_2.2.5"); +__asm__(".symver __p_type,__p_type@GLIBC_2.2.5"); +__asm__(".symver __p_type_syms,__p_type_syms@GLIBC_2.2.5"); +__asm__(".symver __pipe,__pipe@GLIBC_2.2.5"); +__asm__(".symver __poll,__poll@GLIBC_2.2.5"); +__asm__(".symver __poll_chk,__poll_chk@GLIBC_2.16"); +__asm__(".symver __posix_getopt,__posix_getopt@GLIBC_2.10"); +__asm__(".symver __pow_finite,__pow_finite@GLIBC_2.15"); +__asm__(".symver __powf_finite,__powf_finite@GLIBC_2.15"); +__asm__(".symver __powl_finite,__powl_finite@GLIBC_2.15"); +__asm__(".symver __ppoll_chk,__ppoll_chk@GLIBC_2.16"); +__asm__(".symver __pread64,__pread64@GLIBC_2.2.5"); +__asm__(".symver __pread64_chk,__pread64_chk@GLIBC_2.4"); +__asm__(".symver __pread_chk,__pread_chk@GLIBC_2.4"); +__asm__(".symver __printf_chk,__printf_chk@GLIBC_2.3.4"); +__asm__(".symver __printf_fp,__printf_fp@GLIBC_2.2.5"); +__asm__(".symver __profile_frequency,__profile_frequency@GLIBC_2.2.5"); +__asm__(".symver __progname,__progname@GLIBC_2.2.5"); +__asm__(".symver __progname_full,__progname_full@GLIBC_2.2.5"); +__asm__(".symver __pthread_cleanup_routine,__pthread_cleanup_routine@GLIBC_2.3.3"); +__asm__(".symver __pthread_getspecific,__pthread_getspecific@GLIBC_2.2.5"); +#ifndef _GLIBCXX_SHARED +#ifndef IN_LIBGCC2 +#ifdef _REENTRANT +__asm__(".symver __pthread_key_create,__pthread_key_create@GLIBC_2.2.5"); +#endif +#endif +#endif +__asm__(".symver __pthread_mutex_destroy,__pthread_mutex_destroy@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutex_init,__pthread_mutex_init@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutex_lock,__pthread_mutex_lock@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutex_trylock,__pthread_mutex_trylock@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutex_unlock,__pthread_mutex_unlock@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutexattr_destroy,__pthread_mutexattr_destroy@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutexattr_init,__pthread_mutexattr_init@GLIBC_2.2.5"); +__asm__(".symver __pthread_mutexattr_settype,__pthread_mutexattr_settype@GLIBC_2.2.5"); +__asm__(".symver __pthread_once,__pthread_once@GLIBC_2.2.5"); +__asm__(".symver __pthread_register_cancel,__pthread_register_cancel@GLIBC_2.3.3"); +__asm__(".symver __pthread_register_cancel_defer,__pthread_register_cancel_defer@GLIBC_2.3.3"); +__asm__(".symver __pthread_rwlock_destroy,__pthread_rwlock_destroy@GLIBC_2.2.5"); +__asm__(".symver __pthread_rwlock_init,__pthread_rwlock_init@GLIBC_2.2.5"); +__asm__(".symver __pthread_rwlock_rdlock,__pthread_rwlock_rdlock@GLIBC_2.2.5"); +__asm__(".symver __pthread_rwlock_tryrdlock,__pthread_rwlock_tryrdlock@GLIBC_2.2.5"); +__asm__(".symver __pthread_rwlock_trywrlock,__pthread_rwlock_trywrlock@GLIBC_2.2.5"); +__asm__(".symver __pthread_rwlock_unlock,__pthread_rwlock_unlock@GLIBC_2.2.5"); +__asm__(".symver __pthread_rwlock_wrlock,__pthread_rwlock_wrlock@GLIBC_2.2.5"); +__asm__(".symver __pthread_setspecific,__pthread_setspecific@GLIBC_2.2.5"); +__asm__(".symver __pthread_unregister_cancel,__pthread_unregister_cancel@GLIBC_2.3.3"); +__asm__(".symver __pthread_unregister_cancel_restore,__pthread_unregister_cancel_restore@GLIBC_2.3.3"); +__asm__(".symver __pthread_unwind_next,__pthread_unwind_next@GLIBC_2.3.3"); +__asm__(".symver __ptsname_r_chk,__ptsname_r_chk@GLIBC_2.4"); +__asm__(".symver __putlong,__putlong@GLIBC_2.2.5"); +__asm__(".symver __putshort,__putshort@GLIBC_2.2.5"); +__asm__(".symver __pwrite64,__pwrite64@GLIBC_2.2.5"); +__asm__(".symver __rawmemchr,__rawmemchr@GLIBC_2.2.5"); +__asm__(".symver __rcmd_errstr,__rcmd_errstr@GLIBC_2.2.5"); +__asm__(".symver __read,__read@GLIBC_2.2.5"); +__asm__(".symver __read_chk,__read_chk@GLIBC_2.4"); +__asm__(".symver __readlink_chk,__readlink_chk@GLIBC_2.4"); +__asm__(".symver __readlinkat_chk,__readlinkat_chk@GLIBC_2.5"); +__asm__(".symver __realloc_hook,__realloc_hook@GLIBC_2.2.5"); +__asm__(".symver __realpath_chk,__realpath_chk@GLIBC_2.4"); +__asm__(".symver __recv_chk,__recv_chk@GLIBC_2.4"); +__asm__(".symver __recvfrom_chk,__recvfrom_chk@GLIBC_2.4"); +#ifdef _REENTRANT +__asm__(".symver __register_atfork,__register_atfork@GLIBC_2.3.2"); +#endif +__asm__(".symver __remainder_finite,__remainder_finite@GLIBC_2.15"); +__asm__(".symver __remainderf_finite,__remainderf_finite@GLIBC_2.15"); +__asm__(".symver __remainderl_finite,__remainderl_finite@GLIBC_2.15"); +__asm__(".symver __res_close,__res_close@GLIBC_2.2.5"); +__asm__(".symver __res_dnok,__res_dnok@GLIBC_2.2.5"); +__asm__(".symver __res_hnok,__res_hnok@GLIBC_2.2.5"); +__asm__(".symver __res_hostalias,__res_hostalias@GLIBC_2.2.5"); +__asm__(".symver __res_init,__res_init@GLIBC_2.2.5"); +__asm__(".symver __res_isourserver,__res_isourserver@GLIBC_2.2.5"); +__asm__(".symver __res_mailok,__res_mailok@GLIBC_2.2.5"); +__asm__(".symver __res_mkquery,__res_mkquery@GLIBC_2.2.5"); +__asm__(".symver __res_nameinquery,__res_nameinquery@GLIBC_2.2.5"); +__asm__(".symver __res_nclose,__res_nclose@GLIBC_2.2.5"); +__asm__(".symver __res_ninit,__res_ninit@GLIBC_2.2.5"); +__asm__(".symver __res_nmkquery,__res_nmkquery@GLIBC_2.2.5"); +__asm__(".symver __res_nquery,__res_nquery@GLIBC_2.2.5"); +__asm__(".symver __res_nquerydomain,__res_nquerydomain@GLIBC_2.2.5"); +__asm__(".symver __res_nsearch,__res_nsearch@GLIBC_2.2.5"); +__asm__(".symver __res_nsend,__res_nsend@GLIBC_2.2.5"); +__asm__(".symver __res_ownok,__res_ownok@GLIBC_2.2.5"); +__asm__(".symver __res_queriesmatch,__res_queriesmatch@GLIBC_2.2.5"); +__asm__(".symver __res_query,__res_query@GLIBC_2.2.5"); +__asm__(".symver __res_querydomain,__res_querydomain@GLIBC_2.2.5"); +__asm__(".symver __res_randomid,__res_randomid@GLIBC_2.2.5"); +__asm__(".symver __res_search,__res_search@GLIBC_2.2.5"); +__asm__(".symver __res_send,__res_send@GLIBC_2.2.5"); +__asm__(".symver __res_state,__res_state@GLIBC_2.2.5"); +__asm__(".symver __rpc_thread_svc_max_pollfd,__rpc_thread_svc_max_pollfd@GLIBC_2.2.5"); +__asm__(".symver __rpc_thread_svc_pollfd,__rpc_thread_svc_pollfd@GLIBC_2.2.5"); +__asm__(".symver __sbrk,__sbrk@GLIBC_2.2.5"); +__asm__(".symver __scalb_finite,__scalb_finite@GLIBC_2.15"); +__asm__(".symver __scalbf_finite,__scalbf_finite@GLIBC_2.15"); +__asm__(".symver __scalbl_finite,__scalbl_finite@GLIBC_2.15"); +__asm__(".symver __sched_cpualloc,__sched_cpualloc@GLIBC_2.7"); +__asm__(".symver __sched_cpucount,__sched_cpucount@GLIBC_2.6"); +__asm__(".symver __sched_cpufree,__sched_cpufree@GLIBC_2.7"); +__asm__(".symver __sched_get_priority_max,__sched_get_priority_max@GLIBC_2.2.5"); +__asm__(".symver __sched_get_priority_min,__sched_get_priority_min@GLIBC_2.2.5"); +__asm__(".symver __sched_getparam,__sched_getparam@GLIBC_2.2.5"); +__asm__(".symver __sched_getscheduler,__sched_getscheduler@GLIBC_2.2.5"); +__asm__(".symver __sched_setscheduler,__sched_setscheduler@GLIBC_2.2.5"); +__asm__(".symver __sched_yield,__sched_yield@GLIBC_2.2.5"); +__asm__(".symver __select,__select@GLIBC_2.2.5"); +__asm__(".symver __send,__send@GLIBC_2.2.5"); +__asm__(".symver __setmntent,__setmntent@GLIBC_2.2.5"); +__asm__(".symver __setpgid,__setpgid@GLIBC_2.2.5"); +__asm__(".symver __sigaction,__sigaction@GLIBC_2.2.5"); +__asm__(".symver __sigaddset,__sigaddset@GLIBC_2.2.5"); +__asm__(".symver __sigdelset,__sigdelset@GLIBC_2.2.5"); +__asm__(".symver __sigismember,__sigismember@GLIBC_2.2.5"); +__asm__(".symver __signbit,__signbit@GLIBC_2.2.5"); +__asm__(".symver __signbitf,__signbitf@GLIBC_2.2.5"); +__asm__(".symver __signbitl,__signbitl@GLIBC_2.2.5"); +__asm__(".symver __signgam,__signgam@GLIBC_2.23"); +__asm__(".symver __sigpause,__sigpause@GLIBC_2.2.5"); +__asm__(".symver __sigsetjmp,__sigsetjmp@GLIBC_2.2.5"); +__asm__(".symver __sigsuspend,__sigsuspend@GLIBC_2.2.5"); +__asm__(".symver __sinh_finite,__sinh_finite@GLIBC_2.15"); +__asm__(".symver __sinhf_finite,__sinhf_finite@GLIBC_2.15"); +__asm__(".symver __sinhl_finite,__sinhl_finite@GLIBC_2.15"); +__asm__(".symver __snprintf_chk,__snprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __sprintf_chk,__sprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __sqrt_finite,__sqrt_finite@GLIBC_2.15"); +__asm__(".symver __sqrtf_finite,__sqrtf_finite@GLIBC_2.15"); +__asm__(".symver __sqrtl_finite,__sqrtl_finite@GLIBC_2.15"); +__asm__(".symver __stack_chk_fail,__stack_chk_fail@GLIBC_2.4"); +__asm__(".symver __statfs,__statfs@GLIBC_2.2.5"); +__asm__(".symver __stpcpy,__stpcpy@GLIBC_2.2.5"); +__asm__(".symver __stpcpy_chk,__stpcpy_chk@GLIBC_2.3.4"); +__asm__(".symver __stpcpy_small,__stpcpy_small@GLIBC_2.2.5"); +__asm__(".symver __stpncpy,__stpncpy@GLIBC_2.2.5"); +__asm__(".symver __stpncpy_chk,__stpncpy_chk@GLIBC_2.4"); +__asm__(".symver __strcasecmp,__strcasecmp@GLIBC_2.2.5"); +__asm__(".symver __strcasecmp_l,__strcasecmp_l@GLIBC_2.2.5"); +__asm__(".symver __strcasestr,__strcasestr@GLIBC_2.2.5"); +__asm__(".symver __strcat_chk,__strcat_chk@GLIBC_2.3.4"); +__asm__(".symver __strcoll_l,__strcoll_l@GLIBC_2.2.5"); +__asm__(".symver __strcpy_chk,__strcpy_chk@GLIBC_2.3.4"); +__asm__(".symver __strcpy_small,__strcpy_small@GLIBC_2.2.5"); +__asm__(".symver __strcspn_c1,__strcspn_c1@GLIBC_2.2.5"); +__asm__(".symver __strcspn_c2,__strcspn_c2@GLIBC_2.2.5"); +__asm__(".symver __strcspn_c3,__strcspn_c3@GLIBC_2.2.5"); +__asm__(".symver __strdup,__strdup@GLIBC_2.2.5"); +__asm__(".symver __strerror_r,__strerror_r@GLIBC_2.2.5"); +__asm__(".symver __strfmon_l,__strfmon_l@GLIBC_2.2.5"); +__asm__(".symver __strftime_l,__strftime_l@GLIBC_2.3"); +__asm__(".symver __strncasecmp_l,__strncasecmp_l@GLIBC_2.2.5"); +__asm__(".symver __strncat_chk,__strncat_chk@GLIBC_2.3.4"); +__asm__(".symver __strncpy_chk,__strncpy_chk@GLIBC_2.3.4"); +__asm__(".symver __strndup,__strndup@GLIBC_2.2.5"); +__asm__(".symver __strpbrk_c2,__strpbrk_c2@GLIBC_2.2.5"); +__asm__(".symver __strpbrk_c3,__strpbrk_c3@GLIBC_2.2.5"); +__asm__(".symver __strsep_1c,__strsep_1c@GLIBC_2.2.5"); +__asm__(".symver __strsep_2c,__strsep_2c@GLIBC_2.2.5"); +__asm__(".symver __strsep_3c,__strsep_3c@GLIBC_2.2.5"); +__asm__(".symver __strsep_g,__strsep_g@GLIBC_2.2.5"); +__asm__(".symver __strspn_c1,__strspn_c1@GLIBC_2.2.5"); +__asm__(".symver __strspn_c2,__strspn_c2@GLIBC_2.2.5"); +__asm__(".symver __strspn_c3,__strspn_c3@GLIBC_2.2.5"); +__asm__(".symver __strtod_internal,__strtod_internal@GLIBC_2.2.5"); +__asm__(".symver __strtod_l,__strtod_l@GLIBC_2.2.5"); +__asm__(".symver __strtof_internal,__strtof_internal@GLIBC_2.2.5"); +__asm__(".symver __strtof_l,__strtof_l@GLIBC_2.2.5"); +__asm__(".symver __strtok_r,__strtok_r@GLIBC_2.2.5"); +__asm__(".symver __strtok_r_1c,__strtok_r_1c@GLIBC_2.2.5"); +__asm__(".symver __strtol_internal,__strtol_internal@GLIBC_2.2.5"); +__asm__(".symver __strtol_l,__strtol_l@GLIBC_2.2.5"); +__asm__(".symver __strtold_internal,__strtold_internal@GLIBC_2.2.5"); +__asm__(".symver __strtold_l,__strtold_l@GLIBC_2.2.5"); +__asm__(".symver __strtoll_internal,__strtoll_internal@GLIBC_2.2.5"); +__asm__(".symver __strtoll_l,__strtoll_l@GLIBC_2.2.5"); +__asm__(".symver __strtoul_internal,__strtoul_internal@GLIBC_2.2.5"); +__asm__(".symver __strtoul_l,__strtoul_l@GLIBC_2.2.5"); +__asm__(".symver __strtoull_internal,__strtoull_internal@GLIBC_2.2.5"); +__asm__(".symver __strtoull_l,__strtoull_l@GLIBC_2.2.5"); +__asm__(".symver __strverscmp,__strverscmp@GLIBC_2.2.5"); +__asm__(".symver __strxfrm_l,__strxfrm_l@GLIBC_2.2.5"); +__asm__(".symver __swprintf_chk,__swprintf_chk@GLIBC_2.4"); +__asm__(".symver __sym_ntop,__sym_ntop@GLIBC_2.2.5"); +__asm__(".symver __sym_ntos,__sym_ntos@GLIBC_2.2.5"); +__asm__(".symver __sym_ston,__sym_ston@GLIBC_2.2.5"); +__asm__(".symver __sysconf,__sysconf@GLIBC_2.2.5"); +__asm__(".symver __sysctl,__sysctl@GLIBC_2.2.5"); +__asm__(".symver __syslog_chk,__syslog_chk@GLIBC_2.4"); +__asm__(".symver __sysv_signal,__sysv_signal@GLIBC_2.2.5"); +__asm__(".symver __timezone,__timezone@GLIBC_2.2.5"); +__asm__(".symver __tls_get_addr,__tls_get_addr@GLIBC_2.3"); +__asm__(".symver __toascii_l,__toascii_l@GLIBC_2.2.5"); +__asm__(".symver __tolower_l,__tolower_l@GLIBC_2.2.5"); +__asm__(".symver __toupper_l,__toupper_l@GLIBC_2.2.5"); +__asm__(".symver __towctrans,__towctrans@GLIBC_2.2.5"); +__asm__(".symver __towctrans_l,__towctrans_l@GLIBC_2.2.5"); +__asm__(".symver __towlower_l,__towlower_l@GLIBC_2.2.5"); +__asm__(".symver __towupper_l,__towupper_l@GLIBC_2.2.5"); +__asm__(".symver __ttyname_r_chk,__ttyname_r_chk@GLIBC_2.4"); +__asm__(".symver __tzname,__tzname@GLIBC_2.2.5"); +__asm__(".symver __uflow,__uflow@GLIBC_2.2.5"); +__asm__(".symver __underflow,__underflow@GLIBC_2.2.5"); +__asm__(".symver __uselocale,__uselocale@GLIBC_2.3"); +__asm__(".symver __vasprintf_chk,__vasprintf_chk@GLIBC_2.8"); +__asm__(".symver __vdprintf_chk,__vdprintf_chk@GLIBC_2.8"); +__asm__(".symver __vfork,__vfork@GLIBC_2.2.5"); +__asm__(".symver __vfprintf_chk,__vfprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __vfscanf,__vfscanf@GLIBC_2.2.5"); +__asm__(".symver __vfwprintf_chk,__vfwprintf_chk@GLIBC_2.4"); +__asm__(".symver __vprintf_chk,__vprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __vsnprintf,__vsnprintf@GLIBC_2.2.5"); +__asm__(".symver __vsnprintf_chk,__vsnprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __vsprintf_chk,__vsprintf_chk@GLIBC_2.3.4"); +__asm__(".symver __vsscanf,__vsscanf@GLIBC_2.2.5"); +__asm__(".symver __vswprintf_chk,__vswprintf_chk@GLIBC_2.4"); +__asm__(".symver __vsyslog_chk,__vsyslog_chk@GLIBC_2.4"); +__asm__(".symver __vwprintf_chk,__vwprintf_chk@GLIBC_2.4"); +__asm__(".symver __wait,__wait@GLIBC_2.2.5"); +__asm__(".symver __waitpid,__waitpid@GLIBC_2.2.5"); +__asm__(".symver __wcpcpy_chk,__wcpcpy_chk@GLIBC_2.4"); +__asm__(".symver __wcpncpy_chk,__wcpncpy_chk@GLIBC_2.4"); +__asm__(".symver __wcrtomb_chk,__wcrtomb_chk@GLIBC_2.4"); +__asm__(".symver __wcscasecmp_l,__wcscasecmp_l@GLIBC_2.2.5"); +__asm__(".symver __wcscat_chk,__wcscat_chk@GLIBC_2.4"); +__asm__(".symver __wcscoll_l,__wcscoll_l@GLIBC_2.2.5"); +__asm__(".symver __wcscpy_chk,__wcscpy_chk@GLIBC_2.4"); +__asm__(".symver __wcsftime_l,__wcsftime_l@GLIBC_2.3"); +__asm__(".symver __wcsncasecmp_l,__wcsncasecmp_l@GLIBC_2.2.5"); +__asm__(".symver __wcsncat_chk,__wcsncat_chk@GLIBC_2.4"); +__asm__(".symver __wcsncpy_chk,__wcsncpy_chk@GLIBC_2.4"); +__asm__(".symver __wcsnrtombs_chk,__wcsnrtombs_chk@GLIBC_2.4"); +__asm__(".symver __wcsrtombs_chk,__wcsrtombs_chk@GLIBC_2.4"); +__asm__(".symver __wcstod_internal,__wcstod_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstod_l,__wcstod_l@GLIBC_2.2.5"); +__asm__(".symver __wcstof_internal,__wcstof_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstof_l,__wcstof_l@GLIBC_2.2.5"); +__asm__(".symver __wcstol_internal,__wcstol_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstol_l,__wcstol_l@GLIBC_2.2.5"); +__asm__(".symver __wcstold_internal,__wcstold_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstold_l,__wcstold_l@GLIBC_2.2.5"); +__asm__(".symver __wcstoll_internal,__wcstoll_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstoll_l,__wcstoll_l@GLIBC_2.2.5"); +__asm__(".symver __wcstombs_chk,__wcstombs_chk@GLIBC_2.4"); +__asm__(".symver __wcstoul_internal,__wcstoul_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstoul_l,__wcstoul_l@GLIBC_2.2.5"); +__asm__(".symver __wcstoull_internal,__wcstoull_internal@GLIBC_2.2.5"); +__asm__(".symver __wcstoull_l,__wcstoull_l@GLIBC_2.2.5"); +__asm__(".symver __wcsxfrm_l,__wcsxfrm_l@GLIBC_2.2.5"); +__asm__(".symver __wctomb_chk,__wctomb_chk@GLIBC_2.4"); +__asm__(".symver __wctrans_l,__wctrans_l@GLIBC_2.2.5"); +__asm__(".symver __wctype_l,__wctype_l@GLIBC_2.2.5"); +__asm__(".symver __wmemcpy_chk,__wmemcpy_chk@GLIBC_2.4"); +__asm__(".symver __wmemmove_chk,__wmemmove_chk@GLIBC_2.4"); +__asm__(".symver __wmempcpy_chk,__wmempcpy_chk@GLIBC_2.4"); +__asm__(".symver __wmemset_chk,__wmemset_chk@GLIBC_2.4"); +__asm__(".symver __woverflow,__woverflow@GLIBC_2.2.5"); +__asm__(".symver __wprintf_chk,__wprintf_chk@GLIBC_2.4"); +__asm__(".symver __write,__write@GLIBC_2.2.5"); +__asm__(".symver __wuflow,__wuflow@GLIBC_2.2.5"); +__asm__(".symver __wunderflow,__wunderflow@GLIBC_2.2.5"); +__asm__(".symver __xmknod,__xmknod@GLIBC_2.2.5"); +__asm__(".symver __xmknodat,__xmknodat@GLIBC_2.4"); +__asm__(".symver __xpg_basename,__xpg_basename@GLIBC_2.2.5"); +__asm__(".symver __xpg_sigpause,__xpg_sigpause@GLIBC_2.2.5"); +__asm__(".symver __xpg_strerror_r,__xpg_strerror_r@GLIBC_2.3.4"); +__asm__(".symver __xstat,__xstat@GLIBC_2.2.5"); +__asm__(".symver __xstat64,__xstat64@GLIBC_2.2.5"); +__asm__(".symver __y0_finite,__y0_finite@GLIBC_2.15"); +__asm__(".symver __y0f_finite,__y0f_finite@GLIBC_2.15"); +__asm__(".symver __y0l_finite,__y0l_finite@GLIBC_2.15"); +__asm__(".symver __y1_finite,__y1_finite@GLIBC_2.15"); +__asm__(".symver __y1f_finite,__y1f_finite@GLIBC_2.15"); +__asm__(".symver __y1l_finite,__y1l_finite@GLIBC_2.15"); +__asm__(".symver __yn_finite,__yn_finite@GLIBC_2.15"); +__asm__(".symver __ynf_finite,__ynf_finite@GLIBC_2.15"); +__asm__(".symver __ynl_finite,__ynl_finite@GLIBC_2.15"); +__asm__(".symver __yp_check,__yp_check@GLIBC_2.2.5"); +__asm__(".symver _dl_mcount,_dl_mcount@GLIBC_2.2.5"); +__asm__(".symver _dl_mcount_wrapper,_dl_mcount_wrapper@GLIBC_2.2.5"); +__asm__(".symver _dl_mcount_wrapper_check,_dl_mcount_wrapper_check@GLIBC_2.2.5"); +__asm__(".symver _environ,_environ@GLIBC_2.2.5"); +__asm__(".symver _exit,_exit@GLIBC_2.2.5"); +__asm__(".symver _flushlbf,_flushlbf@GLIBC_2.2.5"); +__asm__(".symver _gethtbyaddr,_gethtbyaddr@GLIBC_2.2.5"); +__asm__(".symver _gethtbyname,_gethtbyname@GLIBC_2.2.5"); +__asm__(".symver _gethtbyname2,_gethtbyname2@GLIBC_2.2.5"); +__asm__(".symver _gethtent,_gethtent@GLIBC_2.2.5"); +__asm__(".symver _getlong,_getlong@GLIBC_2.2.5"); +__asm__(".symver _getshort,_getshort@GLIBC_2.2.5"); +__asm__(".symver _libc_intl_domainname,_libc_intl_domainname@GLIBC_2.2.5"); +__asm__(".symver _longjmp,_longjmp@GLIBC_2.2.5"); +__asm__(".symver _mcleanup,_mcleanup@GLIBC_2.2.5"); +__asm__(".symver _mcount,_mcount@GLIBC_2.2.5"); +__asm__(".symver _nl_default_dirname,_nl_default_dirname@GLIBC_2.2.5"); +__asm__(".symver _nl_domain_bindings,_nl_domain_bindings@GLIBC_2.2.5"); +__asm__(".symver _nl_msg_cat_cntr,_nl_msg_cat_cntr@GLIBC_2.2.5"); +__asm__(".symver _obstack_allocated_p,_obstack_allocated_p@GLIBC_2.2.5"); +__asm__(".symver _obstack_begin,_obstack_begin@GLIBC_2.2.5"); +__asm__(".symver _obstack_begin_1,_obstack_begin_1@GLIBC_2.2.5"); +__asm__(".symver _obstack_free,_obstack_free@GLIBC_2.2.5"); +__asm__(".symver _obstack_memory_used,_obstack_memory_used@GLIBC_2.2.5"); +__asm__(".symver _obstack_newchunk,_obstack_newchunk@GLIBC_2.2.5"); +__asm__(".symver _pthread_cleanup_pop,_pthread_cleanup_pop@GLIBC_2.2.5"); +__asm__(".symver _pthread_cleanup_pop_restore,_pthread_cleanup_pop_restore@GLIBC_2.2.5"); +__asm__(".symver _pthread_cleanup_push,_pthread_cleanup_push@GLIBC_2.2.5"); +__asm__(".symver _pthread_cleanup_push_defer,_pthread_cleanup_push_defer@GLIBC_2.2.5"); +__asm__(".symver _r_debug,_r_debug@GLIBC_2.2.5"); +__asm__(".symver _res_hconf,_res_hconf@GLIBC_2.2.5"); +__asm__(".symver _res_opcodes,_res_opcodes@GLIBC_2.2.5"); +__asm__(".symver _sethtent,_sethtent@GLIBC_2.2.5"); +__asm__(".symver _setjmp,_setjmp@GLIBC_2.2.5"); +__asm__(".symver _sys_errlist,_sys_errlist@GLIBC_2.12"); +__asm__(".symver _sys_nerr,_sys_nerr@GLIBC_2.12"); +__asm__(".symver _sys_siglist,_sys_siglist@GLIBC_2.3.3"); +__asm__(".symver _tolower,_tolower@GLIBC_2.2.5"); +__asm__(".symver _toupper,_toupper@GLIBC_2.2.5"); +__asm__(".symver a64l,a64l@GLIBC_2.2.5"); +__asm__(".symver abort,abort@GLIBC_2.2.5"); +__asm__(".symver abs,abs@GLIBC_2.2.5"); +__asm__(".symver accept,accept@GLIBC_2.2.5"); +__asm__(".symver accept4,accept4@GLIBC_2.10"); +__asm__(".symver access,access@GLIBC_2.2.5"); +__asm__(".symver acct,acct@GLIBC_2.2.5"); +__asm__(".symver acos,acos@GLIBC_2.2.5"); +__asm__(".symver acosf,acosf@GLIBC_2.2.5"); +__asm__(".symver acosh,acosh@GLIBC_2.2.5"); +__asm__(".symver acoshf,acoshf@GLIBC_2.2.5"); +__asm__(".symver acoshl,acoshl@GLIBC_2.2.5"); +__asm__(".symver acosl,acosl@GLIBC_2.2.5"); +__asm__(".symver addmntent,addmntent@GLIBC_2.2.5"); +__asm__(".symver addseverity,addseverity@GLIBC_2.2.5"); +__asm__(".symver adjtime,adjtime@GLIBC_2.2.5"); +__asm__(".symver adjtimex,adjtimex@GLIBC_2.2.5"); +__asm__(".symver aio_cancel,aio_cancel@GLIBC_2.2.5"); +__asm__(".symver aio_cancel64,aio_cancel64@GLIBC_2.2.5"); +__asm__(".symver aio_error,aio_error@GLIBC_2.2.5"); +__asm__(".symver aio_error64,aio_error64@GLIBC_2.2.5"); +__asm__(".symver aio_fsync,aio_fsync@GLIBC_2.2.5"); +__asm__(".symver aio_fsync64,aio_fsync64@GLIBC_2.2.5"); +__asm__(".symver aio_init,aio_init@GLIBC_2.2.5"); +__asm__(".symver aio_read,aio_read@GLIBC_2.2.5"); +__asm__(".symver aio_read64,aio_read64@GLIBC_2.2.5"); +__asm__(".symver aio_return,aio_return@GLIBC_2.2.5"); +__asm__(".symver aio_return64,aio_return64@GLIBC_2.2.5"); +__asm__(".symver aio_suspend,aio_suspend@GLIBC_2.2.5"); +__asm__(".symver aio_suspend64,aio_suspend64@GLIBC_2.2.5"); +__asm__(".symver aio_write,aio_write@GLIBC_2.2.5"); +__asm__(".symver aio_write64,aio_write64@GLIBC_2.2.5"); +__asm__(".symver alarm,alarm@GLIBC_2.2.5"); +__asm__(".symver aligned_alloc,aligned_alloc@GLIBC_2.16"); +__asm__(".symver alphasort,alphasort@GLIBC_2.2.5"); +__asm__(".symver alphasort64,alphasort64@GLIBC_2.2.5"); +__asm__(".symver arch_prctl,arch_prctl@GLIBC_2.2.5"); +__asm__(".symver argp_err_exit_status,argp_err_exit_status@GLIBC_2.2.5"); +__asm__(".symver argp_error,argp_error@GLIBC_2.2.5"); +__asm__(".symver argp_failure,argp_failure@GLIBC_2.2.5"); +__asm__(".symver argp_help,argp_help@GLIBC_2.2.5"); +__asm__(".symver argp_parse,argp_parse@GLIBC_2.2.5"); +__asm__(".symver argp_program_bug_address,argp_program_bug_address@GLIBC_2.2.5"); +__asm__(".symver argp_program_version,argp_program_version@GLIBC_2.2.5"); +__asm__(".symver argp_program_version_hook,argp_program_version_hook@GLIBC_2.2.5"); +__asm__(".symver argp_state_help,argp_state_help@GLIBC_2.2.5"); +__asm__(".symver argp_usage,argp_usage@GLIBC_2.2.5"); +__asm__(".symver argz_add,argz_add@GLIBC_2.2.5"); +__asm__(".symver argz_add_sep,argz_add_sep@GLIBC_2.2.5"); +__asm__(".symver argz_append,argz_append@GLIBC_2.2.5"); +__asm__(".symver argz_count,argz_count@GLIBC_2.2.5"); +__asm__(".symver argz_create,argz_create@GLIBC_2.2.5"); +__asm__(".symver argz_create_sep,argz_create_sep@GLIBC_2.2.5"); +__asm__(".symver argz_delete,argz_delete@GLIBC_2.2.5"); +__asm__(".symver argz_extract,argz_extract@GLIBC_2.2.5"); +__asm__(".symver argz_insert,argz_insert@GLIBC_2.2.5"); +__asm__(".symver argz_next,argz_next@GLIBC_2.2.5"); +__asm__(".symver argz_replace,argz_replace@GLIBC_2.2.5"); +__asm__(".symver argz_stringify,argz_stringify@GLIBC_2.2.5"); +__asm__(".symver asctime,asctime@GLIBC_2.2.5"); +__asm__(".symver asctime_r,asctime_r@GLIBC_2.2.5"); +__asm__(".symver asin,asin@GLIBC_2.2.5"); +__asm__(".symver asinf,asinf@GLIBC_2.2.5"); +__asm__(".symver asinh,asinh@GLIBC_2.2.5"); +__asm__(".symver asinhf,asinhf@GLIBC_2.2.5"); +__asm__(".symver asinhl,asinhl@GLIBC_2.2.5"); +__asm__(".symver asinl,asinl@GLIBC_2.2.5"); +__asm__(".symver asprintf,asprintf@GLIBC_2.2.5"); +__asm__(".symver atan,atan@GLIBC_2.2.5"); +__asm__(".symver atan2,atan2@GLIBC_2.2.5"); +__asm__(".symver atan2f,atan2f@GLIBC_2.2.5"); +__asm__(".symver atan2l,atan2l@GLIBC_2.2.5"); +__asm__(".symver atanf,atanf@GLIBC_2.2.5"); +__asm__(".symver atanh,atanh@GLIBC_2.2.5"); +__asm__(".symver atanhf,atanhf@GLIBC_2.2.5"); +__asm__(".symver atanhl,atanhl@GLIBC_2.2.5"); +__asm__(".symver atanl,atanl@GLIBC_2.2.5"); +__asm__(".symver atof,atof@GLIBC_2.2.5"); +__asm__(".symver atoi,atoi@GLIBC_2.2.5"); +__asm__(".symver atol,atol@GLIBC_2.2.5"); +__asm__(".symver atoll,atoll@GLIBC_2.2.5"); +__asm__(".symver authdes_create,authdes_create@GLIBC_2.2.5"); +__asm__(".symver authdes_pk_create,authdes_pk_create@GLIBC_2.2.5"); +__asm__(".symver authunix_create_default,authunix_create_default@GLIBC_2.2.5"); +__asm__(".symver backtrace,backtrace@GLIBC_2.2.5"); +__asm__(".symver backtrace_symbols,backtrace_symbols@GLIBC_2.2.5"); +__asm__(".symver backtrace_symbols_fd,backtrace_symbols_fd@GLIBC_2.2.5"); +__asm__(".symver basename,basename@GLIBC_2.2.5"); +__asm__(".symver bcmp,bcmp@GLIBC_2.2.5"); +__asm__(".symver bcopy,bcopy@GLIBC_2.2.5"); +__asm__(".symver bind,bind@GLIBC_2.2.5"); +__asm__(".symver bind_textdomain_codeset,bind_textdomain_codeset@GLIBC_2.2.5"); +__asm__(".symver bindresvport,bindresvport@GLIBC_2.2.5"); +__asm__(".symver bindtextdomain,bindtextdomain@GLIBC_2.2.5"); +__asm__(".symver brk,brk@GLIBC_2.2.5"); +__asm__(".symver bsd_signal,bsd_signal@GLIBC_2.2.5"); +__asm__(".symver bsearch,bsearch@GLIBC_2.2.5"); +__asm__(".symver btowc,btowc@GLIBC_2.2.5"); +__asm__(".symver bzero,bzero@GLIBC_2.2.5"); +__asm__(".symver c16rtomb,c16rtomb@GLIBC_2.16"); +__asm__(".symver c32rtomb,c32rtomb@GLIBC_2.16"); +__asm__(".symver cabs,cabs@GLIBC_2.2.5"); +__asm__(".symver cabsf,cabsf@GLIBC_2.2.5"); +__asm__(".symver cabsl,cabsl@GLIBC_2.2.5"); +__asm__(".symver cacos,cacos@GLIBC_2.2.5"); +__asm__(".symver cacosf,cacosf@GLIBC_2.2.5"); +__asm__(".symver cacosh,cacosh@GLIBC_2.2.5"); +__asm__(".symver cacoshf,cacoshf@GLIBC_2.2.5"); +__asm__(".symver cacoshl,cacoshl@GLIBC_2.2.5"); +__asm__(".symver cacosl,cacosl@GLIBC_2.2.5"); +__asm__(".symver calloc,calloc@GLIBC_2.2.5"); +__asm__(".symver canonicalize_file_name,canonicalize_file_name@GLIBC_2.2.5"); +__asm__(".symver capget,capget@GLIBC_2.2.5"); +__asm__(".symver capset,capset@GLIBC_2.2.5"); +__asm__(".symver carg,carg@GLIBC_2.2.5"); +__asm__(".symver cargf,cargf@GLIBC_2.2.5"); +__asm__(".symver cargl,cargl@GLIBC_2.2.5"); +__asm__(".symver casin,casin@GLIBC_2.2.5"); +__asm__(".symver casinf,casinf@GLIBC_2.2.5"); +__asm__(".symver casinh,casinh@GLIBC_2.2.5"); +__asm__(".symver casinhf,casinhf@GLIBC_2.2.5"); +__asm__(".symver casinhl,casinhl@GLIBC_2.2.5"); +__asm__(".symver casinl,casinl@GLIBC_2.2.5"); +__asm__(".symver catan,catan@GLIBC_2.2.5"); +__asm__(".symver catanf,catanf@GLIBC_2.2.5"); +__asm__(".symver catanh,catanh@GLIBC_2.2.5"); +__asm__(".symver catanhf,catanhf@GLIBC_2.2.5"); +__asm__(".symver catanhl,catanhl@GLIBC_2.2.5"); +__asm__(".symver catanl,catanl@GLIBC_2.2.5"); +__asm__(".symver catclose,catclose@GLIBC_2.2.5"); +__asm__(".symver catgets,catgets@GLIBC_2.2.5"); +__asm__(".symver catopen,catopen@GLIBC_2.2.5"); +__asm__(".symver cbrt,cbrt@GLIBC_2.2.5"); +__asm__(".symver cbrtf,cbrtf@GLIBC_2.2.5"); +__asm__(".symver cbrtl,cbrtl@GLIBC_2.2.5"); +__asm__(".symver ccos,ccos@GLIBC_2.2.5"); +__asm__(".symver ccosf,ccosf@GLIBC_2.2.5"); +__asm__(".symver ccosh,ccosh@GLIBC_2.2.5"); +__asm__(".symver ccoshf,ccoshf@GLIBC_2.2.5"); +__asm__(".symver ccoshl,ccoshl@GLIBC_2.2.5"); +__asm__(".symver ccosl,ccosl@GLIBC_2.2.5"); +__asm__(".symver ceil,ceil@GLIBC_2.2.5"); +__asm__(".symver ceilf,ceilf@GLIBC_2.2.5"); +__asm__(".symver ceill,ceill@GLIBC_2.2.5"); +__asm__(".symver cexp,cexp@GLIBC_2.2.5"); +__asm__(".symver cexpf,cexpf@GLIBC_2.2.5"); +__asm__(".symver cexpl,cexpl@GLIBC_2.2.5"); +__asm__(".symver cfgetispeed,cfgetispeed@GLIBC_2.2.5"); +__asm__(".symver cfgetospeed,cfgetospeed@GLIBC_2.2.5"); +__asm__(".symver cfmakeraw,cfmakeraw@GLIBC_2.2.5"); +__asm__(".symver cfree,cfree@GLIBC_2.2.5"); +__asm__(".symver cfsetispeed,cfsetispeed@GLIBC_2.2.5"); +__asm__(".symver cfsetospeed,cfsetospeed@GLIBC_2.2.5"); +__asm__(".symver cfsetspeed,cfsetspeed@GLIBC_2.2.5"); +__asm__(".symver chdir,chdir@GLIBC_2.2.5"); +__asm__(".symver chflags,chflags@GLIBC_2.2.5"); +__asm__(".symver chmod,chmod@GLIBC_2.2.5"); +__asm__(".symver chown,chown@GLIBC_2.2.5"); +__asm__(".symver chroot,chroot@GLIBC_2.2.5"); +__asm__(".symver cimag,cimag@GLIBC_2.2.5"); +__asm__(".symver cimagf,cimagf@GLIBC_2.2.5"); +__asm__(".symver cimagl,cimagl@GLIBC_2.2.5"); +__asm__(".symver clearenv,clearenv@GLIBC_2.2.5"); +__asm__(".symver clearerr,clearerr@GLIBC_2.2.5"); +__asm__(".symver clearerr_unlocked,clearerr_unlocked@GLIBC_2.2.5"); +__asm__(".symver clnt_create,clnt_create@GLIBC_2.2.5"); +__asm__(".symver clnt_pcreateerror,clnt_pcreateerror@GLIBC_2.2.5"); +__asm__(".symver clnt_perror,clnt_perror@GLIBC_2.2.5"); +__asm__(".symver clnt_sperrno,clnt_sperrno@GLIBC_2.2.5"); +__asm__(".symver clnttcp_create,clnttcp_create@GLIBC_2.2.5"); +__asm__(".symver clntudp_create,clntudp_create@GLIBC_2.2.5"); +__asm__(".symver clock,clock@GLIBC_2.2.5"); +__asm__(".symver clock_adjtime,clock_adjtime@GLIBC_2.14"); +__asm__(".symver clock_getcpuclockid,clock_getcpuclockid@GLIBC_2.17"); +__asm__(".symver clock_getres,clock_getres@GLIBC_2.17"); +__asm__(".symver clock_gettime,clock_gettime@GLIBC_2.17"); +__asm__(".symver clock_nanosleep,clock_nanosleep@GLIBC_2.17"); +__asm__(".symver clock_settime,clock_settime@GLIBC_2.17"); +__asm__(".symver clog,clog@GLIBC_2.2.5"); +__asm__(".symver clog10,clog10@GLIBC_2.2.5"); +__asm__(".symver clog10f,clog10f@GLIBC_2.2.5"); +__asm__(".symver clog10l,clog10l@GLIBC_2.2.5"); +__asm__(".symver clogf,clogf@GLIBC_2.2.5"); +__asm__(".symver clogl,clogl@GLIBC_2.2.5"); +__asm__(".symver clone,clone@GLIBC_2.2.5"); +__asm__(".symver close,close@GLIBC_2.2.5"); +__asm__(".symver closedir,closedir@GLIBC_2.2.5"); +__asm__(".symver closelog,closelog@GLIBC_2.2.5"); +__asm__(".symver confstr,confstr@GLIBC_2.2.5"); +__asm__(".symver conj,conj@GLIBC_2.2.5"); +__asm__(".symver conjf,conjf@GLIBC_2.2.5"); +__asm__(".symver conjl,conjl@GLIBC_2.2.5"); +__asm__(".symver connect,connect@GLIBC_2.2.5"); +__asm__(".symver copysign,copysign@GLIBC_2.2.5"); +__asm__(".symver copysignf,copysignf@GLIBC_2.2.5"); +__asm__(".symver copysignl,copysignl@GLIBC_2.2.5"); +__asm__(".symver cos,cos@GLIBC_2.2.5"); +__asm__(".symver cosf,cosf@GLIBC_2.2.5"); +__asm__(".symver cosh,cosh@GLIBC_2.2.5"); +__asm__(".symver coshf,coshf@GLIBC_2.2.5"); +__asm__(".symver coshl,coshl@GLIBC_2.2.5"); +__asm__(".symver cosl,cosl@GLIBC_2.2.5"); +__asm__(".symver cpow,cpow@GLIBC_2.2.5"); +__asm__(".symver cpowf,cpowf@GLIBC_2.2.5"); +__asm__(".symver cpowl,cpowl@GLIBC_2.2.5"); +__asm__(".symver cproj,cproj@GLIBC_2.2.5"); +__asm__(".symver cprojf,cprojf@GLIBC_2.2.5"); +__asm__(".symver cprojl,cprojl@GLIBC_2.2.5"); +__asm__(".symver creal,creal@GLIBC_2.2.5"); +__asm__(".symver crealf,crealf@GLIBC_2.2.5"); +__asm__(".symver creall,creall@GLIBC_2.2.5"); +__asm__(".symver creat,creat@GLIBC_2.2.5"); +__asm__(".symver creat64,creat64@GLIBC_2.2.5"); +__asm__(".symver crypt,crypt@GLIBC_2.2.5"); +__asm__(".symver crypt_r,crypt_r@GLIBC_2.2.5"); +__asm__(".symver csin,csin@GLIBC_2.2.5"); +__asm__(".symver csinf,csinf@GLIBC_2.2.5"); +__asm__(".symver csinh,csinh@GLIBC_2.2.5"); +__asm__(".symver csinhf,csinhf@GLIBC_2.2.5"); +__asm__(".symver csinhl,csinhl@GLIBC_2.2.5"); +__asm__(".symver csinl,csinl@GLIBC_2.2.5"); +__asm__(".symver csqrt,csqrt@GLIBC_2.2.5"); +__asm__(".symver csqrtf,csqrtf@GLIBC_2.2.5"); +__asm__(".symver csqrtl,csqrtl@GLIBC_2.2.5"); +__asm__(".symver ctan,ctan@GLIBC_2.2.5"); +__asm__(".symver ctanf,ctanf@GLIBC_2.2.5"); +__asm__(".symver ctanh,ctanh@GLIBC_2.2.5"); +__asm__(".symver ctanhf,ctanhf@GLIBC_2.2.5"); +__asm__(".symver ctanhl,ctanhl@GLIBC_2.2.5"); +__asm__(".symver ctanl,ctanl@GLIBC_2.2.5"); +__asm__(".symver ctermid,ctermid@GLIBC_2.2.5"); +__asm__(".symver ctime,ctime@GLIBC_2.2.5"); +__asm__(".symver ctime_r,ctime_r@GLIBC_2.2.5"); +__asm__(".symver cuserid,cuserid@GLIBC_2.2.5"); +__asm__(".symver daemon,daemon@GLIBC_2.2.5"); +__asm__(".symver daylight,daylight@GLIBC_2.2.5"); +__asm__(".symver dcgettext,dcgettext@GLIBC_2.2.5"); +__asm__(".symver dcngettext,dcngettext@GLIBC_2.2.5"); +__asm__(".symver delete_module,delete_module@GLIBC_2.2.5"); +__asm__(".symver dgettext,dgettext@GLIBC_2.2.5"); +__asm__(".symver difftime,difftime@GLIBC_2.2.5"); +__asm__(".symver dirfd,dirfd@GLIBC_2.2.5"); +__asm__(".symver dirname,dirname@GLIBC_2.2.5"); +__asm__(".symver div,div@GLIBC_2.2.5"); +__asm__(".symver dl_iterate_phdr,dl_iterate_phdr@GLIBC_2.2.5"); +__asm__(".symver dladdr,dladdr@GLIBC_2.2.5"); +__asm__(".symver dladdr1,dladdr1@GLIBC_2.3.3"); +__asm__(".symver dlclose,dlclose@GLIBC_2.2.5"); +__asm__(".symver dlerror,dlerror@GLIBC_2.2.5"); +__asm__(".symver dlinfo,dlinfo@GLIBC_2.3.3"); +__asm__(".symver dlmopen,dlmopen@GLIBC_2.3.4"); +__asm__(".symver dlopen,dlopen@GLIBC_2.2.5"); +__asm__(".symver dlsym,dlsym@GLIBC_2.2.5"); +__asm__(".symver dlvsym,dlvsym@GLIBC_2.2.5"); +__asm__(".symver dngettext,dngettext@GLIBC_2.2.5"); +__asm__(".symver dprintf,dprintf@GLIBC_2.2.5"); +__asm__(".symver drand48,drand48@GLIBC_2.2.5"); +__asm__(".symver drand48_r,drand48_r@GLIBC_2.2.5"); +__asm__(".symver drem,drem@GLIBC_2.2.5"); +__asm__(".symver dremf,dremf@GLIBC_2.2.5"); +__asm__(".symver dreml,dreml@GLIBC_2.2.5"); +__asm__(".symver dup,dup@GLIBC_2.2.5"); +__asm__(".symver dup2,dup2@GLIBC_2.2.5"); +__asm__(".symver dup3,dup3@GLIBC_2.9"); +__asm__(".symver duplocale,duplocale@GLIBC_2.3"); +__asm__(".symver dysize,dysize@GLIBC_2.2.5"); +__asm__(".symver eaccess,eaccess@GLIBC_2.4"); +__asm__(".symver ecvt,ecvt@GLIBC_2.2.5"); +__asm__(".symver ecvt_r,ecvt_r@GLIBC_2.2.5"); +__asm__(".symver encrypt,encrypt@GLIBC_2.2.5"); +__asm__(".symver encrypt_r,encrypt_r@GLIBC_2.2.5"); +__asm__(".symver endaliasent,endaliasent@GLIBC_2.2.5"); +__asm__(".symver endfsent,endfsent@GLIBC_2.2.5"); +__asm__(".symver endgrent,endgrent@GLIBC_2.2.5"); +__asm__(".symver endhostent,endhostent@GLIBC_2.2.5"); +__asm__(".symver endmntent,endmntent@GLIBC_2.2.5"); +__asm__(".symver endnetent,endnetent@GLIBC_2.2.5"); +__asm__(".symver endnetgrent,endnetgrent@GLIBC_2.2.5"); +__asm__(".symver endprotoent,endprotoent@GLIBC_2.2.5"); +__asm__(".symver endpwent,endpwent@GLIBC_2.2.5"); +__asm__(".symver endrpcent,endrpcent@GLIBC_2.2.5"); +__asm__(".symver endservent,endservent@GLIBC_2.2.5"); +__asm__(".symver endsgent,endsgent@GLIBC_2.10"); +__asm__(".symver endspent,endspent@GLIBC_2.2.5"); +__asm__(".symver endttyent,endttyent@GLIBC_2.2.5"); +__asm__(".symver endusershell,endusershell@GLIBC_2.2.5"); +__asm__(".symver endutent,endutent@GLIBC_2.2.5"); +__asm__(".symver endutxent,endutxent@GLIBC_2.2.5"); +__asm__(".symver environ,environ@GLIBC_2.2.5"); +__asm__(".symver envz_add,envz_add@GLIBC_2.2.5"); +__asm__(".symver envz_entry,envz_entry@GLIBC_2.2.5"); +__asm__(".symver envz_get,envz_get@GLIBC_2.2.5"); +__asm__(".symver envz_merge,envz_merge@GLIBC_2.2.5"); +__asm__(".symver envz_remove,envz_remove@GLIBC_2.2.5"); +__asm__(".symver envz_strip,envz_strip@GLIBC_2.2.5"); +__asm__(".symver epoll_create,epoll_create@GLIBC_2.3.2"); +__asm__(".symver epoll_create1,epoll_create1@GLIBC_2.9"); +__asm__(".symver epoll_ctl,epoll_ctl@GLIBC_2.3.2"); +__asm__(".symver epoll_pwait,epoll_pwait@GLIBC_2.6"); +__asm__(".symver epoll_wait,epoll_wait@GLIBC_2.3.2"); +__asm__(".symver erand48,erand48@GLIBC_2.2.5"); +__asm__(".symver erand48_r,erand48_r@GLIBC_2.2.5"); +__asm__(".symver erf,erf@GLIBC_2.2.5"); +__asm__(".symver erfc,erfc@GLIBC_2.2.5"); +__asm__(".symver erfcf,erfcf@GLIBC_2.2.5"); +__asm__(".symver erfcl,erfcl@GLIBC_2.2.5"); +__asm__(".symver erff,erff@GLIBC_2.2.5"); +__asm__(".symver erfl,erfl@GLIBC_2.2.5"); +__asm__(".symver err,err@GLIBC_2.2.5"); +__asm__(".symver error,error@GLIBC_2.2.5"); +__asm__(".symver error_at_line,error_at_line@GLIBC_2.2.5"); +__asm__(".symver error_message_count,error_message_count@GLIBC_2.2.5"); +__asm__(".symver error_one_per_line,error_one_per_line@GLIBC_2.2.5"); +__asm__(".symver error_print_progname,error_print_progname@GLIBC_2.2.5"); +__asm__(".symver errx,errx@GLIBC_2.2.5"); +__asm__(".symver ether_aton,ether_aton@GLIBC_2.2.5"); +__asm__(".symver ether_aton_r,ether_aton_r@GLIBC_2.2.5"); +__asm__(".symver ether_hostton,ether_hostton@GLIBC_2.2.5"); +__asm__(".symver ether_line,ether_line@GLIBC_2.2.5"); +__asm__(".symver ether_ntoa,ether_ntoa@GLIBC_2.2.5"); +__asm__(".symver ether_ntoa_r,ether_ntoa_r@GLIBC_2.2.5"); +__asm__(".symver ether_ntohost,ether_ntohost@GLIBC_2.2.5"); +__asm__(".symver euidaccess,euidaccess@GLIBC_2.2.5"); +__asm__(".symver eventfd,eventfd@GLIBC_2.7"); +__asm__(".symver eventfd_read,eventfd_read@GLIBC_2.7"); +__asm__(".symver eventfd_write,eventfd_write@GLIBC_2.7"); +__asm__(".symver execl,execl@GLIBC_2.2.5"); +__asm__(".symver execle,execle@GLIBC_2.2.5"); +__asm__(".symver execlp,execlp@GLIBC_2.2.5"); +__asm__(".symver execv,execv@GLIBC_2.2.5"); +__asm__(".symver execve,execve@GLIBC_2.2.5"); +__asm__(".symver execvp,execvp@GLIBC_2.2.5"); +__asm__(".symver execvpe,execvpe@GLIBC_2.11"); +__asm__(".symver exit,exit@GLIBC_2.2.5"); +__asm__(".symver exp,exp@GLIBC_2.2.5"); +__asm__(".symver exp10,exp10@GLIBC_2.2.5"); +__asm__(".symver exp10f,exp10f@GLIBC_2.2.5"); +__asm__(".symver exp10l,exp10l@GLIBC_2.2.5"); +__asm__(".symver exp2,exp2@GLIBC_2.2.5"); +__asm__(".symver exp2f,exp2f@GLIBC_2.2.5"); +__asm__(".symver exp2l,exp2l@GLIBC_2.2.5"); +__asm__(".symver expf,expf@GLIBC_2.2.5"); +__asm__(".symver expl,expl@GLIBC_2.2.5"); +__asm__(".symver expm1,expm1@GLIBC_2.2.5"); +__asm__(".symver expm1f,expm1f@GLIBC_2.2.5"); +__asm__(".symver expm1l,expm1l@GLIBC_2.2.5"); +__asm__(".symver fabs,fabs@GLIBC_2.2.5"); +__asm__(".symver fabsf,fabsf@GLIBC_2.2.5"); +__asm__(".symver fabsl,fabsl@GLIBC_2.2.5"); +__asm__(".symver faccessat,faccessat@GLIBC_2.4"); +__asm__(".symver fallocate,fallocate@GLIBC_2.10"); +__asm__(".symver fallocate64,fallocate64@GLIBC_2.10"); +__asm__(".symver fanotify_init,fanotify_init@GLIBC_2.13"); +__asm__(".symver fanotify_mark,fanotify_mark@GLIBC_2.13"); +__asm__(".symver fattach,fattach@GLIBC_2.2.5"); +__asm__(".symver fchdir,fchdir@GLIBC_2.2.5"); +__asm__(".symver fchflags,fchflags@GLIBC_2.2.5"); +__asm__(".symver fchmod,fchmod@GLIBC_2.2.5"); +__asm__(".symver fchmodat,fchmodat@GLIBC_2.4"); +__asm__(".symver fchown,fchown@GLIBC_2.2.5"); +__asm__(".symver fchownat,fchownat@GLIBC_2.4"); +__asm__(".symver fclose,fclose@GLIBC_2.2.5"); +__asm__(".symver fcloseall,fcloseall@GLIBC_2.2.5"); +__asm__(".symver fcntl,fcntl@GLIBC_2.2.5"); +__asm__(".symver fcrypt,fcrypt@GLIBC_2.2.5"); +__asm__(".symver fcvt,fcvt@GLIBC_2.2.5"); +__asm__(".symver fcvt_r,fcvt_r@GLIBC_2.2.5"); +__asm__(".symver fdatasync,fdatasync@GLIBC_2.2.5"); +__asm__(".symver fdetach,fdetach@GLIBC_2.2.5"); +__asm__(".symver fdim,fdim@GLIBC_2.2.5"); +__asm__(".symver fdimf,fdimf@GLIBC_2.2.5"); +__asm__(".symver fdiml,fdiml@GLIBC_2.2.5"); +__asm__(".symver fdopen,fdopen@GLIBC_2.2.5"); +__asm__(".symver fdopendir,fdopendir@GLIBC_2.4"); +__asm__(".symver feclearexcept,feclearexcept@GLIBC_2.2.5"); +__asm__(".symver fedisableexcept,fedisableexcept@GLIBC_2.2.5"); +__asm__(".symver feenableexcept,feenableexcept@GLIBC_2.2.5"); +__asm__(".symver fegetenv,fegetenv@GLIBC_2.2.5"); +__asm__(".symver fegetexcept,fegetexcept@GLIBC_2.2.5"); +__asm__(".symver fegetexceptflag,fegetexceptflag@GLIBC_2.2.5"); +__asm__(".symver fegetround,fegetround@GLIBC_2.2.5"); +__asm__(".symver feholdexcept,feholdexcept@GLIBC_2.2.5"); +__asm__(".symver feof,feof@GLIBC_2.2.5"); +__asm__(".symver feof_unlocked,feof_unlocked@GLIBC_2.2.5"); +__asm__(".symver feraiseexcept,feraiseexcept@GLIBC_2.2.5"); +__asm__(".symver ferror,ferror@GLIBC_2.2.5"); +__asm__(".symver ferror_unlocked,ferror_unlocked@GLIBC_2.2.5"); +__asm__(".symver fesetenv,fesetenv@GLIBC_2.2.5"); +__asm__(".symver fesetexceptflag,fesetexceptflag@GLIBC_2.2.5"); +__asm__(".symver fesetround,fesetround@GLIBC_2.2.5"); +__asm__(".symver fetestexcept,fetestexcept@GLIBC_2.2.5"); +__asm__(".symver feupdateenv,feupdateenv@GLIBC_2.2.5"); +__asm__(".symver fexecve,fexecve@GLIBC_2.2.5"); +__asm__(".symver fflush,fflush@GLIBC_2.2.5"); +__asm__(".symver fflush_unlocked,fflush_unlocked@GLIBC_2.2.5"); +__asm__(".symver ffs,ffs@GLIBC_2.2.5"); +__asm__(".symver ffsl,ffsl@GLIBC_2.2.5"); +__asm__(".symver ffsll,ffsll@GLIBC_2.2.5"); +__asm__(".symver fgetc,fgetc@GLIBC_2.2.5"); +__asm__(".symver fgetc_unlocked,fgetc_unlocked@GLIBC_2.2.5"); +__asm__(".symver fgetgrent,fgetgrent@GLIBC_2.2.5"); +__asm__(".symver fgetgrent_r,fgetgrent_r@GLIBC_2.2.5"); +__asm__(".symver fgetpos,fgetpos@GLIBC_2.2.5"); +__asm__(".symver fgetpos64,fgetpos64@GLIBC_2.2.5"); +__asm__(".symver fgetpwent,fgetpwent@GLIBC_2.2.5"); +__asm__(".symver fgetpwent_r,fgetpwent_r@GLIBC_2.2.5"); +__asm__(".symver fgets,fgets@GLIBC_2.2.5"); +__asm__(".symver fgets_unlocked,fgets_unlocked@GLIBC_2.2.5"); +__asm__(".symver fgetsgent,fgetsgent@GLIBC_2.10"); +__asm__(".symver fgetsgent_r,fgetsgent_r@GLIBC_2.10"); +__asm__(".symver fgetspent,fgetspent@GLIBC_2.2.5"); +__asm__(".symver fgetspent_r,fgetspent_r@GLIBC_2.2.5"); +__asm__(".symver fgetwc,fgetwc@GLIBC_2.2.5"); +__asm__(".symver fgetwc_unlocked,fgetwc_unlocked@GLIBC_2.2.5"); +__asm__(".symver fgetws,fgetws@GLIBC_2.2.5"); +__asm__(".symver fgetws_unlocked,fgetws_unlocked@GLIBC_2.2.5"); +__asm__(".symver fgetxattr,fgetxattr@GLIBC_2.3"); +__asm__(".symver fileno,fileno@GLIBC_2.2.5"); +__asm__(".symver fileno_unlocked,fileno_unlocked@GLIBC_2.2.5"); +__asm__(".symver finite,finite@GLIBC_2.2.5"); +__asm__(".symver finitef,finitef@GLIBC_2.2.5"); +__asm__(".symver finitel,finitel@GLIBC_2.2.5"); +__asm__(".symver flistxattr,flistxattr@GLIBC_2.3"); +__asm__(".symver flock,flock@GLIBC_2.2.5"); +__asm__(".symver flockfile,flockfile@GLIBC_2.2.5"); +__asm__(".symver floor,floor@GLIBC_2.2.5"); +__asm__(".symver floorf,floorf@GLIBC_2.2.5"); +__asm__(".symver floorl,floorl@GLIBC_2.2.5"); +__asm__(".symver fma,fma@GLIBC_2.2.5"); +__asm__(".symver fmaf,fmaf@GLIBC_2.2.5"); +__asm__(".symver fmal,fmal@GLIBC_2.2.5"); +__asm__(".symver fmax,fmax@GLIBC_2.2.5"); +__asm__(".symver fmaxf,fmaxf@GLIBC_2.2.5"); +__asm__(".symver fmaxl,fmaxl@GLIBC_2.2.5"); +__asm__(".symver fmemopen,fmemopen@GLIBC_2.22"); +__asm__(".symver fmin,fmin@GLIBC_2.2.5"); +__asm__(".symver fminf,fminf@GLIBC_2.2.5"); +__asm__(".symver fminl,fminl@GLIBC_2.2.5"); +__asm__(".symver fmod,fmod@GLIBC_2.2.5"); +__asm__(".symver fmodf,fmodf@GLIBC_2.2.5"); +__asm__(".symver fmodl,fmodl@GLIBC_2.2.5"); +__asm__(".symver fmtmsg,fmtmsg@GLIBC_2.2.5"); +__asm__(".symver fnmatch,fnmatch@GLIBC_2.2.5"); +__asm__(".symver fopen,fopen@GLIBC_2.2.5"); +__asm__(".symver fopen64,fopen64@GLIBC_2.2.5"); +__asm__(".symver fopencookie,fopencookie@GLIBC_2.2.5"); +__asm__(".symver fork,fork@GLIBC_2.2.5"); +__asm__(".symver forkpty,forkpty@GLIBC_2.2.5"); +__asm__(".symver fpathconf,fpathconf@GLIBC_2.2.5"); +__asm__(".symver fprintf,fprintf@GLIBC_2.2.5"); +__asm__(".symver fputc,fputc@GLIBC_2.2.5"); +__asm__(".symver fputc_unlocked,fputc_unlocked@GLIBC_2.2.5"); +__asm__(".symver fputs,fputs@GLIBC_2.2.5"); +__asm__(".symver fputs_unlocked,fputs_unlocked@GLIBC_2.2.5"); +__asm__(".symver fputwc,fputwc@GLIBC_2.2.5"); +__asm__(".symver fputwc_unlocked,fputwc_unlocked@GLIBC_2.2.5"); +__asm__(".symver fputws,fputws@GLIBC_2.2.5"); +__asm__(".symver fputws_unlocked,fputws_unlocked@GLIBC_2.2.5"); +__asm__(".symver fread,fread@GLIBC_2.2.5"); +__asm__(".symver fread_unlocked,fread_unlocked@GLIBC_2.2.5"); +__asm__(".symver free,free@GLIBC_2.2.5"); +__asm__(".symver freeaddrinfo,freeaddrinfo@GLIBC_2.2.5"); +__asm__(".symver freeifaddrs,freeifaddrs@GLIBC_2.3"); +__asm__(".symver freelocale,freelocale@GLIBC_2.3"); +__asm__(".symver fremovexattr,fremovexattr@GLIBC_2.3"); +__asm__(".symver freopen,freopen@GLIBC_2.2.5"); +__asm__(".symver freopen64,freopen64@GLIBC_2.2.5"); +__asm__(".symver frexp,frexp@GLIBC_2.2.5"); +__asm__(".symver frexpf,frexpf@GLIBC_2.2.5"); +__asm__(".symver frexpl,frexpl@GLIBC_2.2.5"); +__asm__(".symver fscanf,fscanf@GLIBC_2.2.5"); +__asm__(".symver fseek,fseek@GLIBC_2.2.5"); +__asm__(".symver fseeko,fseeko@GLIBC_2.2.5"); +__asm__(".symver fseeko64,fseeko64@GLIBC_2.2.5"); +__asm__(".symver fsetpos,fsetpos@GLIBC_2.2.5"); +__asm__(".symver fsetpos64,fsetpos64@GLIBC_2.2.5"); +__asm__(".symver fsetxattr,fsetxattr@GLIBC_2.3"); +__asm__(".symver fstatfs,fstatfs@GLIBC_2.2.5"); +__asm__(".symver fstatfs64,fstatfs64@GLIBC_2.2.5"); +__asm__(".symver fstatvfs,fstatvfs@GLIBC_2.2.5"); +__asm__(".symver fstatvfs64,fstatvfs64@GLIBC_2.2.5"); +__asm__(".symver fsync,fsync@GLIBC_2.2.5"); +__asm__(".symver ftell,ftell@GLIBC_2.2.5"); +__asm__(".symver ftello,ftello@GLIBC_2.2.5"); +__asm__(".symver ftello64,ftello64@GLIBC_2.2.5"); +__asm__(".symver ftime,ftime@GLIBC_2.2.5"); +__asm__(".symver ftok,ftok@GLIBC_2.2.5"); +__asm__(".symver ftruncate,ftruncate@GLIBC_2.2.5"); +__asm__(".symver ftruncate64,ftruncate64@GLIBC_2.2.5"); +__asm__(".symver ftrylockfile,ftrylockfile@GLIBC_2.2.5"); +__asm__(".symver fts64_children,fts64_children@GLIBC_2.23"); +__asm__(".symver fts64_close,fts64_close@GLIBC_2.23"); +__asm__(".symver fts64_open,fts64_open@GLIBC_2.23"); +__asm__(".symver fts64_read,fts64_read@GLIBC_2.23"); +__asm__(".symver fts64_set,fts64_set@GLIBC_2.23"); +__asm__(".symver fts_children,fts_children@GLIBC_2.2.5"); +__asm__(".symver fts_close,fts_close@GLIBC_2.2.5"); +__asm__(".symver fts_open,fts_open@GLIBC_2.2.5"); +__asm__(".symver fts_read,fts_read@GLIBC_2.2.5"); +__asm__(".symver fts_set,fts_set@GLIBC_2.2.5"); +__asm__(".symver ftw,ftw@GLIBC_2.2.5"); +__asm__(".symver ftw64,ftw64@GLIBC_2.2.5"); +__asm__(".symver funlockfile,funlockfile@GLIBC_2.2.5"); +__asm__(".symver futimens,futimens@GLIBC_2.6"); +__asm__(".symver futimes,futimes@GLIBC_2.3"); +__asm__(".symver futimesat,futimesat@GLIBC_2.4"); +__asm__(".symver fwide,fwide@GLIBC_2.2.5"); +__asm__(".symver fwprintf,fwprintf@GLIBC_2.2.5"); +__asm__(".symver fwrite,fwrite@GLIBC_2.2.5"); +__asm__(".symver fwrite_unlocked,fwrite_unlocked@GLIBC_2.2.5"); +__asm__(".symver fwscanf,fwscanf@GLIBC_2.2.5"); +__asm__(".symver gai_cancel,gai_cancel@GLIBC_2.2.5"); +__asm__(".symver gai_error,gai_error@GLIBC_2.2.5"); +__asm__(".symver gai_strerror,gai_strerror@GLIBC_2.2.5"); +__asm__(".symver gai_suspend,gai_suspend@GLIBC_2.2.5"); +__asm__(".symver gamma,gamma@GLIBC_2.2.5"); +__asm__(".symver gammaf,gammaf@GLIBC_2.2.5"); +__asm__(".symver gammal,gammal@GLIBC_2.2.5"); +__asm__(".symver gcvt,gcvt@GLIBC_2.2.5"); +__asm__(".symver get_avphys_pages,get_avphys_pages@GLIBC_2.2.5"); +__asm__(".symver get_current_dir_name,get_current_dir_name@GLIBC_2.2.5"); +__asm__(".symver get_myaddress,get_myaddress@GLIBC_2.2.5"); +__asm__(".symver get_nprocs,get_nprocs@GLIBC_2.2.5"); +__asm__(".symver get_nprocs_conf,get_nprocs_conf@GLIBC_2.2.5"); +__asm__(".symver get_phys_pages,get_phys_pages@GLIBC_2.2.5"); +__asm__(".symver getaddrinfo,getaddrinfo@GLIBC_2.2.5"); +__asm__(".symver getaddrinfo_a,getaddrinfo_a@GLIBC_2.2.5"); +__asm__(".symver getaliasbyname,getaliasbyname@GLIBC_2.2.5"); +__asm__(".symver getaliasbyname_r,getaliasbyname_r@GLIBC_2.2.5"); +__asm__(".symver getaliasent,getaliasent@GLIBC_2.2.5"); +__asm__(".symver getaliasent_r,getaliasent_r@GLIBC_2.2.5"); +__asm__(".symver getauxval,getauxval@GLIBC_2.16"); +__asm__(".symver getc,getc@GLIBC_2.2.5"); +__asm__(".symver getc_unlocked,getc_unlocked@GLIBC_2.2.5"); +__asm__(".symver getchar,getchar@GLIBC_2.2.5"); +__asm__(".symver getchar_unlocked,getchar_unlocked@GLIBC_2.2.5"); +__asm__(".symver getcontext,getcontext@GLIBC_2.2.5"); +__asm__(".symver getcwd,getcwd@GLIBC_2.2.5"); +__asm__(".symver getdate,getdate@GLIBC_2.2.5"); +__asm__(".symver getdate_err,getdate_err@GLIBC_2.2.5"); +__asm__(".symver getdate_r,getdate_r@GLIBC_2.2.5"); +__asm__(".symver getdelim,getdelim@GLIBC_2.2.5"); +__asm__(".symver getdirentries,getdirentries@GLIBC_2.2.5"); +__asm__(".symver getdirentries64,getdirentries64@GLIBC_2.2.5"); +__asm__(".symver getdomainname,getdomainname@GLIBC_2.2.5"); +__asm__(".symver getdtablesize,getdtablesize@GLIBC_2.2.5"); +__asm__(".symver getegid,getegid@GLIBC_2.2.5"); +__asm__(".symver getenv,getenv@GLIBC_2.2.5"); +__asm__(".symver geteuid,geteuid@GLIBC_2.2.5"); +__asm__(".symver getfsent,getfsent@GLIBC_2.2.5"); +__asm__(".symver getfsfile,getfsfile@GLIBC_2.2.5"); +__asm__(".symver getfsspec,getfsspec@GLIBC_2.2.5"); +__asm__(".symver getgid,getgid@GLIBC_2.2.5"); +__asm__(".symver getgrent,getgrent@GLIBC_2.2.5"); +__asm__(".symver getgrent_r,getgrent_r@GLIBC_2.2.5"); +__asm__(".symver getgrgid,getgrgid@GLIBC_2.2.5"); +__asm__(".symver getgrgid_r,getgrgid_r@GLIBC_2.2.5"); +__asm__(".symver getgrnam,getgrnam@GLIBC_2.2.5"); +__asm__(".symver getgrnam_r,getgrnam_r@GLIBC_2.2.5"); +__asm__(".symver getgrouplist,getgrouplist@GLIBC_2.2.5"); +__asm__(".symver getgroups,getgroups@GLIBC_2.2.5"); +__asm__(".symver gethostbyaddr,gethostbyaddr@GLIBC_2.2.5"); +__asm__(".symver gethostbyaddr_r,gethostbyaddr_r@GLIBC_2.2.5"); +__asm__(".symver gethostbyname,gethostbyname@GLIBC_2.2.5"); +__asm__(".symver gethostbyname2,gethostbyname2@GLIBC_2.2.5"); +__asm__(".symver gethostbyname2_r,gethostbyname2_r@GLIBC_2.2.5"); +__asm__(".symver gethostbyname_r,gethostbyname_r@GLIBC_2.2.5"); +__asm__(".symver gethostent,gethostent@GLIBC_2.2.5"); +__asm__(".symver gethostent_r,gethostent_r@GLIBC_2.2.5"); +__asm__(".symver gethostid,gethostid@GLIBC_2.2.5"); +__asm__(".symver gethostname,gethostname@GLIBC_2.2.5"); +__asm__(".symver getifaddrs,getifaddrs@GLIBC_2.3"); +__asm__(".symver getipv4sourcefilter,getipv4sourcefilter@GLIBC_2.3.4"); +__asm__(".symver getitimer,getitimer@GLIBC_2.2.5"); +__asm__(".symver getline,getline@GLIBC_2.2.5"); +__asm__(".symver getloadavg,getloadavg@GLIBC_2.2.5"); +__asm__(".symver getlogin,getlogin@GLIBC_2.2.5"); +__asm__(".symver getlogin_r,getlogin_r@GLIBC_2.2.5"); +__asm__(".symver getmntent,getmntent@GLIBC_2.2.5"); +__asm__(".symver getmntent_r,getmntent_r@GLIBC_2.2.5"); +__asm__(".symver getmsg,getmsg@GLIBC_2.2.5"); +__asm__(".symver getnameinfo,getnameinfo@GLIBC_2.2.5"); +__asm__(".symver getnetbyaddr,getnetbyaddr@GLIBC_2.2.5"); +__asm__(".symver getnetbyaddr_r,getnetbyaddr_r@GLIBC_2.2.5"); +__asm__(".symver getnetbyname,getnetbyname@GLIBC_2.2.5"); +__asm__(".symver getnetbyname_r,getnetbyname_r@GLIBC_2.2.5"); +__asm__(".symver getnetent,getnetent@GLIBC_2.2.5"); +__asm__(".symver getnetent_r,getnetent_r@GLIBC_2.2.5"); +__asm__(".symver getnetgrent,getnetgrent@GLIBC_2.2.5"); +__asm__(".symver getnetgrent_r,getnetgrent_r@GLIBC_2.2.5"); +__asm__(".symver getopt,getopt@GLIBC_2.2.5"); +__asm__(".symver getopt_long,getopt_long@GLIBC_2.2.5"); +__asm__(".symver getopt_long_only,getopt_long_only@GLIBC_2.2.5"); +__asm__(".symver getpagesize,getpagesize@GLIBC_2.2.5"); +__asm__(".symver getpass,getpass@GLIBC_2.2.5"); +__asm__(".symver getpeername,getpeername@GLIBC_2.2.5"); +__asm__(".symver getpgid,getpgid@GLIBC_2.2.5"); +__asm__(".symver getpgrp,getpgrp@GLIBC_2.2.5"); +__asm__(".symver getpid,getpid@GLIBC_2.2.5"); +__asm__(".symver getpmsg,getpmsg@GLIBC_2.2.5"); +__asm__(".symver getppid,getppid@GLIBC_2.2.5"); +__asm__(".symver getpriority,getpriority@GLIBC_2.2.5"); +__asm__(".symver getprotobyname,getprotobyname@GLIBC_2.2.5"); +__asm__(".symver getprotobyname_r,getprotobyname_r@GLIBC_2.2.5"); +__asm__(".symver getprotobynumber,getprotobynumber@GLIBC_2.2.5"); +__asm__(".symver getprotobynumber_r,getprotobynumber_r@GLIBC_2.2.5"); +__asm__(".symver getprotoent,getprotoent@GLIBC_2.2.5"); +__asm__(".symver getprotoent_r,getprotoent_r@GLIBC_2.2.5"); +__asm__(".symver getpt,getpt@GLIBC_2.2.5"); +__asm__(".symver getpw,getpw@GLIBC_2.2.5"); +__asm__(".symver getpwent,getpwent@GLIBC_2.2.5"); +__asm__(".symver getpwent_r,getpwent_r@GLIBC_2.2.5"); +__asm__(".symver getpwnam,getpwnam@GLIBC_2.2.5"); +__asm__(".symver getpwnam_r,getpwnam_r@GLIBC_2.2.5"); +__asm__(".symver getpwuid,getpwuid@GLIBC_2.2.5"); +__asm__(".symver getpwuid_r,getpwuid_r@GLIBC_2.2.5"); +__asm__(".symver getresgid,getresgid@GLIBC_2.2.5"); +__asm__(".symver getresuid,getresuid@GLIBC_2.2.5"); +__asm__(".symver getrlimit,getrlimit@GLIBC_2.2.5"); +__asm__(".symver getrlimit64,getrlimit64@GLIBC_2.2.5"); +__asm__(".symver getrpcbyname,getrpcbyname@GLIBC_2.2.5"); +__asm__(".symver getrpcbyname_r,getrpcbyname_r@GLIBC_2.2.5"); +__asm__(".symver getrpcbynumber,getrpcbynumber@GLIBC_2.2.5"); +__asm__(".symver getrpcbynumber_r,getrpcbynumber_r@GLIBC_2.2.5"); +__asm__(".symver getrpcent,getrpcent@GLIBC_2.2.5"); +__asm__(".symver getrpcent_r,getrpcent_r@GLIBC_2.2.5"); +__asm__(".symver getrpcport,getrpcport@GLIBC_2.2.5"); +__asm__(".symver getrusage,getrusage@GLIBC_2.2.5"); +__asm__(".symver gets,gets@GLIBC_2.2.5"); +__asm__(".symver getservbyname,getservbyname@GLIBC_2.2.5"); +__asm__(".symver getservbyname_r,getservbyname_r@GLIBC_2.2.5"); +__asm__(".symver getservbyport,getservbyport@GLIBC_2.2.5"); +__asm__(".symver getservbyport_r,getservbyport_r@GLIBC_2.2.5"); +__asm__(".symver getservent,getservent@GLIBC_2.2.5"); +__asm__(".symver getservent_r,getservent_r@GLIBC_2.2.5"); +__asm__(".symver getsgent,getsgent@GLIBC_2.10"); +__asm__(".symver getsgent_r,getsgent_r@GLIBC_2.10"); +__asm__(".symver getsgnam,getsgnam@GLIBC_2.10"); +__asm__(".symver getsgnam_r,getsgnam_r@GLIBC_2.10"); +__asm__(".symver getsid,getsid@GLIBC_2.2.5"); +__asm__(".symver getsockname,getsockname@GLIBC_2.2.5"); +__asm__(".symver getsockopt,getsockopt@GLIBC_2.2.5"); +__asm__(".symver getsourcefilter,getsourcefilter@GLIBC_2.3.4"); +__asm__(".symver getspent,getspent@GLIBC_2.2.5"); +__asm__(".symver getspent_r,getspent_r@GLIBC_2.2.5"); +__asm__(".symver getspnam,getspnam@GLIBC_2.2.5"); +__asm__(".symver getspnam_r,getspnam_r@GLIBC_2.2.5"); +__asm__(".symver getsubopt,getsubopt@GLIBC_2.2.5"); +__asm__(".symver gettext,gettext@GLIBC_2.2.5"); +__asm__(".symver gettimeofday,gettimeofday@GLIBC_2.2.5"); +__asm__(".symver getttyent,getttyent@GLIBC_2.2.5"); +__asm__(".symver getttynam,getttynam@GLIBC_2.2.5"); +__asm__(".symver getuid,getuid@GLIBC_2.2.5"); +__asm__(".symver getusershell,getusershell@GLIBC_2.2.5"); +__asm__(".symver getutent,getutent@GLIBC_2.2.5"); +__asm__(".symver getutent_r,getutent_r@GLIBC_2.2.5"); +__asm__(".symver getutid,getutid@GLIBC_2.2.5"); +__asm__(".symver getutid_r,getutid_r@GLIBC_2.2.5"); +__asm__(".symver getutline,getutline@GLIBC_2.2.5"); +__asm__(".symver getutline_r,getutline_r@GLIBC_2.2.5"); +__asm__(".symver getutmp,getutmp@GLIBC_2.2.5"); +__asm__(".symver getutmpx,getutmpx@GLIBC_2.2.5"); +__asm__(".symver getutxent,getutxent@GLIBC_2.2.5"); +__asm__(".symver getutxid,getutxid@GLIBC_2.2.5"); +__asm__(".symver getutxline,getutxline@GLIBC_2.2.5"); +__asm__(".symver getw,getw@GLIBC_2.2.5"); +__asm__(".symver getwc,getwc@GLIBC_2.2.5"); +__asm__(".symver getwc_unlocked,getwc_unlocked@GLIBC_2.2.5"); +__asm__(".symver getwchar,getwchar@GLIBC_2.2.5"); +__asm__(".symver getwchar_unlocked,getwchar_unlocked@GLIBC_2.2.5"); +__asm__(".symver getwd,getwd@GLIBC_2.2.5"); +__asm__(".symver getxattr,getxattr@GLIBC_2.3"); +__asm__(".symver glob,glob@GLIBC_2.2.5"); +__asm__(".symver glob64,glob64@GLIBC_2.2.5"); +__asm__(".symver glob_pattern_p,glob_pattern_p@GLIBC_2.2.5"); +__asm__(".symver globfree,globfree@GLIBC_2.2.5"); +__asm__(".symver globfree64,globfree64@GLIBC_2.2.5"); +__asm__(".symver gmtime,gmtime@GLIBC_2.2.5"); +__asm__(".symver gmtime_r,gmtime_r@GLIBC_2.2.5"); +__asm__(".symver gnu_dev_major,gnu_dev_major@GLIBC_2.3.3"); +__asm__(".symver gnu_dev_makedev,gnu_dev_makedev@GLIBC_2.3.3"); +__asm__(".symver gnu_dev_minor,gnu_dev_minor@GLIBC_2.3.3"); +__asm__(".symver gnu_get_libc_release,gnu_get_libc_release@GLIBC_2.2.5"); +__asm__(".symver gnu_get_libc_version,gnu_get_libc_version@GLIBC_2.2.5"); +__asm__(".symver grantpt,grantpt@GLIBC_2.2.5"); +__asm__(".symver group_member,group_member@GLIBC_2.2.5"); +__asm__(".symver gsignal,gsignal@GLIBC_2.2.5"); +__asm__(".symver gtty,gtty@GLIBC_2.2.5"); +__asm__(".symver h_errlist,h_errlist@GLIBC_2.2.5"); +__asm__(".symver h_nerr,h_nerr@GLIBC_2.2.5"); +__asm__(".symver hasmntopt,hasmntopt@GLIBC_2.2.5"); +__asm__(".symver hcreate,hcreate@GLIBC_2.2.5"); +__asm__(".symver hcreate_r,hcreate_r@GLIBC_2.2.5"); +__asm__(".symver hdestroy,hdestroy@GLIBC_2.2.5"); +__asm__(".symver hdestroy_r,hdestroy_r@GLIBC_2.2.5"); +__asm__(".symver herror,herror@GLIBC_2.2.5"); +__asm__(".symver host2netname,host2netname@GLIBC_2.2.5"); +__asm__(".symver hsearch,hsearch@GLIBC_2.2.5"); +__asm__(".symver hsearch_r,hsearch_r@GLIBC_2.2.5"); +__asm__(".symver hstrerror,hstrerror@GLIBC_2.2.5"); +__asm__(".symver htonl,htonl@GLIBC_2.2.5"); +__asm__(".symver htons,htons@GLIBC_2.2.5"); +__asm__(".symver hypot,hypot@GLIBC_2.2.5"); +__asm__(".symver hypotf,hypotf@GLIBC_2.2.5"); +__asm__(".symver hypotl,hypotl@GLIBC_2.2.5"); +__asm__(".symver iconv,iconv@GLIBC_2.2.5"); +__asm__(".symver iconv_close,iconv_close@GLIBC_2.2.5"); +__asm__(".symver iconv_open,iconv_open@GLIBC_2.2.5"); +__asm__(".symver if_freenameindex,if_freenameindex@GLIBC_2.2.5"); +__asm__(".symver if_indextoname,if_indextoname@GLIBC_2.2.5"); +__asm__(".symver if_nameindex,if_nameindex@GLIBC_2.2.5"); +__asm__(".symver if_nametoindex,if_nametoindex@GLIBC_2.2.5"); +__asm__(".symver ilogb,ilogb@GLIBC_2.2.5"); +__asm__(".symver ilogbf,ilogbf@GLIBC_2.2.5"); +__asm__(".symver ilogbl,ilogbl@GLIBC_2.2.5"); +__asm__(".symver imaxabs,imaxabs@GLIBC_2.2.5"); +__asm__(".symver imaxdiv,imaxdiv@GLIBC_2.2.5"); +__asm__(".symver in6addr_any,in6addr_any@GLIBC_2.2.5"); +__asm__(".symver in6addr_loopback,in6addr_loopback@GLIBC_2.2.5"); +__asm__(".symver index,index@GLIBC_2.2.5"); +__asm__(".symver inet6_opt_append,inet6_opt_append@GLIBC_2.5"); +__asm__(".symver inet6_opt_find,inet6_opt_find@GLIBC_2.5"); +__asm__(".symver inet6_opt_finish,inet6_opt_finish@GLIBC_2.5"); +__asm__(".symver inet6_opt_get_val,inet6_opt_get_val@GLIBC_2.5"); +__asm__(".symver inet6_opt_init,inet6_opt_init@GLIBC_2.5"); +__asm__(".symver inet6_opt_next,inet6_opt_next@GLIBC_2.5"); +__asm__(".symver inet6_opt_set_val,inet6_opt_set_val@GLIBC_2.5"); +__asm__(".symver inet6_option_alloc,inet6_option_alloc@GLIBC_2.3.3"); +__asm__(".symver inet6_option_append,inet6_option_append@GLIBC_2.3.3"); +__asm__(".symver inet6_option_find,inet6_option_find@GLIBC_2.3.3"); +__asm__(".symver inet6_option_init,inet6_option_init@GLIBC_2.3.3"); +__asm__(".symver inet6_option_next,inet6_option_next@GLIBC_2.3.3"); +__asm__(".symver inet6_option_space,inet6_option_space@GLIBC_2.3.3"); +__asm__(".symver inet6_rth_add,inet6_rth_add@GLIBC_2.5"); +__asm__(".symver inet6_rth_getaddr,inet6_rth_getaddr@GLIBC_2.5"); +__asm__(".symver inet6_rth_init,inet6_rth_init@GLIBC_2.5"); +__asm__(".symver inet6_rth_reverse,inet6_rth_reverse@GLIBC_2.5"); +__asm__(".symver inet6_rth_segments,inet6_rth_segments@GLIBC_2.5"); +__asm__(".symver inet6_rth_space,inet6_rth_space@GLIBC_2.5"); +__asm__(".symver inet_addr,inet_addr@GLIBC_2.2.5"); +__asm__(".symver inet_aton,inet_aton@GLIBC_2.2.5"); +__asm__(".symver inet_lnaof,inet_lnaof@GLIBC_2.2.5"); +__asm__(".symver inet_makeaddr,inet_makeaddr@GLIBC_2.2.5"); +__asm__(".symver inet_net_ntop,inet_net_ntop@GLIBC_2.2.5"); +__asm__(".symver inet_net_pton,inet_net_pton@GLIBC_2.2.5"); +__asm__(".symver inet_neta,inet_neta@GLIBC_2.2.5"); +__asm__(".symver inet_netof,inet_netof@GLIBC_2.2.5"); +__asm__(".symver inet_network,inet_network@GLIBC_2.2.5"); +__asm__(".symver inet_nsap_addr,inet_nsap_addr@GLIBC_2.2.5"); +__asm__(".symver inet_nsap_ntoa,inet_nsap_ntoa@GLIBC_2.2.5"); +__asm__(".symver inet_ntoa,inet_ntoa@GLIBC_2.2.5"); +__asm__(".symver inet_ntop,inet_ntop@GLIBC_2.2.5"); +__asm__(".symver inet_pton,inet_pton@GLIBC_2.2.5"); +__asm__(".symver init_module,init_module@GLIBC_2.2.5"); +__asm__(".symver initgroups,initgroups@GLIBC_2.2.5"); +__asm__(".symver initstate,initstate@GLIBC_2.2.5"); +__asm__(".symver initstate_r,initstate_r@GLIBC_2.2.5"); +__asm__(".symver innetgr,innetgr@GLIBC_2.2.5"); +__asm__(".symver inotify_add_watch,inotify_add_watch@GLIBC_2.4"); +__asm__(".symver inotify_init,inotify_init@GLIBC_2.4"); +__asm__(".symver inotify_init1,inotify_init1@GLIBC_2.9"); +__asm__(".symver inotify_rm_watch,inotify_rm_watch@GLIBC_2.4"); +__asm__(".symver insque,insque@GLIBC_2.2.5"); +__asm__(".symver ioctl,ioctl@GLIBC_2.2.5"); +__asm__(".symver ioperm,ioperm@GLIBC_2.2.5"); +__asm__(".symver iopl,iopl@GLIBC_2.2.5"); +__asm__(".symver iruserok,iruserok@GLIBC_2.2.5"); +__asm__(".symver iruserok_af,iruserok_af@GLIBC_2.2.5"); +__asm__(".symver isalnum,isalnum@GLIBC_2.2.5"); +__asm__(".symver isalnum_l,isalnum_l@GLIBC_2.3"); +__asm__(".symver isalpha,isalpha@GLIBC_2.2.5"); +__asm__(".symver isalpha_l,isalpha_l@GLIBC_2.3"); +__asm__(".symver isascii,isascii@GLIBC_2.2.5"); +__asm__(".symver isastream,isastream@GLIBC_2.2.5"); +__asm__(".symver isatty,isatty@GLIBC_2.2.5"); +__asm__(".symver isblank,isblank@GLIBC_2.2.5"); +__asm__(".symver isblank_l,isblank_l@GLIBC_2.3"); +__asm__(".symver iscntrl,iscntrl@GLIBC_2.2.5"); +__asm__(".symver iscntrl_l,iscntrl_l@GLIBC_2.3"); +__asm__(".symver isctype,isctype@GLIBC_2.3"); +__asm__(".symver isdigit,isdigit@GLIBC_2.2.5"); +__asm__(".symver isdigit_l,isdigit_l@GLIBC_2.3"); +__asm__(".symver isfdtype,isfdtype@GLIBC_2.2.5"); +__asm__(".symver isgraph,isgraph@GLIBC_2.2.5"); +__asm__(".symver isgraph_l,isgraph_l@GLIBC_2.3"); +__asm__(".symver isinf,isinf@GLIBC_2.2.5"); +__asm__(".symver isinff,isinff@GLIBC_2.2.5"); +__asm__(".symver isinfl,isinfl@GLIBC_2.2.5"); +__asm__(".symver islower,islower@GLIBC_2.2.5"); +__asm__(".symver islower_l,islower_l@GLIBC_2.3"); +__asm__(".symver isnan,isnan@GLIBC_2.2.5"); +__asm__(".symver isnanf,isnanf@GLIBC_2.2.5"); +__asm__(".symver isnanl,isnanl@GLIBC_2.2.5"); +__asm__(".symver isprint,isprint@GLIBC_2.2.5"); +__asm__(".symver isprint_l,isprint_l@GLIBC_2.3"); +__asm__(".symver ispunct,ispunct@GLIBC_2.2.5"); +__asm__(".symver ispunct_l,ispunct_l@GLIBC_2.3"); +__asm__(".symver isspace,isspace@GLIBC_2.2.5"); +__asm__(".symver isspace_l,isspace_l@GLIBC_2.3"); +__asm__(".symver isupper,isupper@GLIBC_2.2.5"); +__asm__(".symver isupper_l,isupper_l@GLIBC_2.3"); +__asm__(".symver iswalnum,iswalnum@GLIBC_2.2.5"); +__asm__(".symver iswalnum_l,iswalnum_l@GLIBC_2.3"); +__asm__(".symver iswalpha,iswalpha@GLIBC_2.2.5"); +__asm__(".symver iswalpha_l,iswalpha_l@GLIBC_2.3"); +__asm__(".symver iswblank,iswblank@GLIBC_2.2.5"); +__asm__(".symver iswblank_l,iswblank_l@GLIBC_2.3"); +__asm__(".symver iswcntrl,iswcntrl@GLIBC_2.2.5"); +__asm__(".symver iswcntrl_l,iswcntrl_l@GLIBC_2.3"); +__asm__(".symver iswctype,iswctype@GLIBC_2.2.5"); +__asm__(".symver iswctype_l,iswctype_l@GLIBC_2.3"); +__asm__(".symver iswdigit,iswdigit@GLIBC_2.2.5"); +__asm__(".symver iswdigit_l,iswdigit_l@GLIBC_2.3"); +__asm__(".symver iswgraph,iswgraph@GLIBC_2.2.5"); +__asm__(".symver iswgraph_l,iswgraph_l@GLIBC_2.3"); +__asm__(".symver iswlower,iswlower@GLIBC_2.2.5"); +__asm__(".symver iswlower_l,iswlower_l@GLIBC_2.3"); +__asm__(".symver iswprint,iswprint@GLIBC_2.2.5"); +__asm__(".symver iswprint_l,iswprint_l@GLIBC_2.3"); +__asm__(".symver iswpunct,iswpunct@GLIBC_2.2.5"); +__asm__(".symver iswpunct_l,iswpunct_l@GLIBC_2.3"); +__asm__(".symver iswspace,iswspace@GLIBC_2.2.5"); +__asm__(".symver iswspace_l,iswspace_l@GLIBC_2.3"); +__asm__(".symver iswupper,iswupper@GLIBC_2.2.5"); +__asm__(".symver iswupper_l,iswupper_l@GLIBC_2.3"); +__asm__(".symver iswxdigit,iswxdigit@GLIBC_2.2.5"); +__asm__(".symver iswxdigit_l,iswxdigit_l@GLIBC_2.3"); +__asm__(".symver isxdigit,isxdigit@GLIBC_2.2.5"); +__asm__(".symver isxdigit_l,isxdigit_l@GLIBC_2.3"); +__asm__(".symver j0,j0@GLIBC_2.2.5"); +__asm__(".symver j0f,j0f@GLIBC_2.2.5"); +__asm__(".symver j0l,j0l@GLIBC_2.2.5"); +__asm__(".symver j1,j1@GLIBC_2.2.5"); +__asm__(".symver j1f,j1f@GLIBC_2.2.5"); +__asm__(".symver j1l,j1l@GLIBC_2.2.5"); +__asm__(".symver jn,jn@GLIBC_2.2.5"); +__asm__(".symver jnf,jnf@GLIBC_2.2.5"); +__asm__(".symver jnl,jnl@GLIBC_2.2.5"); +__asm__(".symver jrand48,jrand48@GLIBC_2.2.5"); +__asm__(".symver jrand48_r,jrand48_r@GLIBC_2.2.5"); +__asm__(".symver key_gendes,key_gendes@GLIBC_2.2.5"); +__asm__(".symver key_secretkey_is_set,key_secretkey_is_set@GLIBC_2.2.5"); +__asm__(".symver kill,kill@GLIBC_2.2.5"); +__asm__(".symver killpg,killpg@GLIBC_2.2.5"); +__asm__(".symver klogctl,klogctl@GLIBC_2.2.5"); +__asm__(".symver l64a,l64a@GLIBC_2.2.5"); +__asm__(".symver labs,labs@GLIBC_2.2.5"); +__asm__(".symver lchmod,lchmod@GLIBC_2.3.2"); +__asm__(".symver lchown,lchown@GLIBC_2.2.5"); +__asm__(".symver lckpwdf,lckpwdf@GLIBC_2.2.5"); +__asm__(".symver lcong48,lcong48@GLIBC_2.2.5"); +__asm__(".symver lcong48_r,lcong48_r@GLIBC_2.2.5"); +__asm__(".symver ldexp,ldexp@GLIBC_2.2.5"); +__asm__(".symver ldexpf,ldexpf@GLIBC_2.2.5"); +__asm__(".symver ldexpl,ldexpl@GLIBC_2.2.5"); +__asm__(".symver ldiv,ldiv@GLIBC_2.2.5"); +__asm__(".symver lfind,lfind@GLIBC_2.2.5"); +__asm__(".symver lgamma,lgamma@GLIBC_2.23"); +__asm__(".symver lgamma_r,lgamma_r@GLIBC_2.2.5"); +__asm__(".symver lgammaf,lgammaf@GLIBC_2.23"); +__asm__(".symver lgammaf_r,lgammaf_r@GLIBC_2.2.5"); +__asm__(".symver lgammal,lgammal@GLIBC_2.23"); +__asm__(".symver lgammal_r,lgammal_r@GLIBC_2.2.5"); +__asm__(".symver lgetxattr,lgetxattr@GLIBC_2.3"); +__asm__(".symver link,link@GLIBC_2.2.5"); +__asm__(".symver linkat,linkat@GLIBC_2.4"); +__asm__(".symver lio_listio,lio_listio@GLIBC_2.4"); +__asm__(".symver lio_listio64,lio_listio64@GLIBC_2.4"); +__asm__(".symver listen,listen@GLIBC_2.2.5"); +__asm__(".symver listxattr,listxattr@GLIBC_2.3"); +__asm__(".symver llabs,llabs@GLIBC_2.2.5"); +__asm__(".symver lldiv,lldiv@GLIBC_2.2.5"); +__asm__(".symver llistxattr,llistxattr@GLIBC_2.3"); +__asm__(".symver llrint,llrint@GLIBC_2.2.5"); +__asm__(".symver llrintf,llrintf@GLIBC_2.2.5"); +__asm__(".symver llrintl,llrintl@GLIBC_2.2.5"); +__asm__(".symver llround,llround@GLIBC_2.2.5"); +__asm__(".symver llroundf,llroundf@GLIBC_2.2.5"); +__asm__(".symver llroundl,llroundl@GLIBC_2.2.5"); +__asm__(".symver llseek,llseek@GLIBC_2.2.5"); +__asm__(".symver localeconv,localeconv@GLIBC_2.2.5"); +__asm__(".symver localtime,localtime@GLIBC_2.2.5"); +__asm__(".symver localtime_r,localtime_r@GLIBC_2.2.5"); +__asm__(".symver lockf,lockf@GLIBC_2.2.5"); +__asm__(".symver lockf64,lockf64@GLIBC_2.2.5"); +__asm__(".symver log,log@GLIBC_2.2.5"); +__asm__(".symver log10,log10@GLIBC_2.2.5"); +__asm__(".symver log10f,log10f@GLIBC_2.2.5"); +__asm__(".symver log10l,log10l@GLIBC_2.2.5"); +__asm__(".symver log1p,log1p@GLIBC_2.2.5"); +__asm__(".symver log1pf,log1pf@GLIBC_2.2.5"); +__asm__(".symver log1pl,log1pl@GLIBC_2.2.5"); +__asm__(".symver log2,log2@GLIBC_2.2.5"); +__asm__(".symver log2f,log2f@GLIBC_2.2.5"); +__asm__(".symver log2l,log2l@GLIBC_2.2.5"); +__asm__(".symver logb,logb@GLIBC_2.2.5"); +__asm__(".symver logbf,logbf@GLIBC_2.2.5"); +__asm__(".symver logbl,logbl@GLIBC_2.2.5"); +__asm__(".symver logf,logf@GLIBC_2.2.5"); +__asm__(".symver login,login@GLIBC_2.2.5"); +__asm__(".symver login_tty,login_tty@GLIBC_2.2.5"); +__asm__(".symver logl,logl@GLIBC_2.2.5"); +__asm__(".symver logout,logout@GLIBC_2.2.5"); +__asm__(".symver logwtmp,logwtmp@GLIBC_2.2.5"); +__asm__(".symver longjmp,longjmp@GLIBC_2.2.5"); +__asm__(".symver lrand48,lrand48@GLIBC_2.2.5"); +__asm__(".symver lrand48_r,lrand48_r@GLIBC_2.2.5"); +__asm__(".symver lremovexattr,lremovexattr@GLIBC_2.3"); +__asm__(".symver lrint,lrint@GLIBC_2.2.5"); +__asm__(".symver lrintf,lrintf@GLIBC_2.2.5"); +__asm__(".symver lrintl,lrintl@GLIBC_2.2.5"); +__asm__(".symver lround,lround@GLIBC_2.2.5"); +__asm__(".symver lroundf,lroundf@GLIBC_2.2.5"); +__asm__(".symver lroundl,lroundl@GLIBC_2.2.5"); +__asm__(".symver lsearch,lsearch@GLIBC_2.2.5"); +__asm__(".symver lseek,lseek@GLIBC_2.2.5"); +__asm__(".symver lseek64,lseek64@GLIBC_2.2.5"); +__asm__(".symver lsetxattr,lsetxattr@GLIBC_2.3"); +__asm__(".symver lutimes,lutimes@GLIBC_2.3"); +__asm__(".symver madvise,madvise@GLIBC_2.2.5"); +__asm__(".symver makecontext,makecontext@GLIBC_2.2.5"); +__asm__(".symver mallinfo,mallinfo@GLIBC_2.2.5"); +__asm__(".symver malloc,malloc@GLIBC_2.2.5"); +__asm__(".symver malloc_get_state,malloc_get_state@GLIBC_2.2.5"); +__asm__(".symver malloc_info,malloc_info@GLIBC_2.10"); +__asm__(".symver malloc_set_state,malloc_set_state@GLIBC_2.2.5"); +__asm__(".symver malloc_stats,malloc_stats@GLIBC_2.2.5"); +__asm__(".symver malloc_trim,malloc_trim@GLIBC_2.2.5"); +__asm__(".symver malloc_usable_size,malloc_usable_size@GLIBC_2.2.5"); +__asm__(".symver mallopt,mallopt@GLIBC_2.2.5"); +__asm__(".symver mallwatch,mallwatch@GLIBC_2.2.5"); +__asm__(".symver matherr,matherr@GLIBC_2.2.5"); +__asm__(".symver mblen,mblen@GLIBC_2.2.5"); +__asm__(".symver mbrlen,mbrlen@GLIBC_2.2.5"); +__asm__(".symver mbrtoc16,mbrtoc16@GLIBC_2.16"); +__asm__(".symver mbrtoc32,mbrtoc32@GLIBC_2.16"); +__asm__(".symver mbrtowc,mbrtowc@GLIBC_2.2.5"); +__asm__(".symver mbsinit,mbsinit@GLIBC_2.2.5"); +__asm__(".symver mbsnrtowcs,mbsnrtowcs@GLIBC_2.2.5"); +__asm__(".symver mbsrtowcs,mbsrtowcs@GLIBC_2.2.5"); +__asm__(".symver mbstowcs,mbstowcs@GLIBC_2.2.5"); +__asm__(".symver mbtowc,mbtowc@GLIBC_2.2.5"); +__asm__(".symver mcheck,mcheck@GLIBC_2.2.5"); +__asm__(".symver mcheck_check_all,mcheck_check_all@GLIBC_2.2.5"); +__asm__(".symver mcheck_pedantic,mcheck_pedantic@GLIBC_2.2.5"); +__asm__(".symver mcount,mcount@GLIBC_2.2.5"); +__asm__(".symver memalign,memalign@GLIBC_2.2.5"); +__asm__(".symver memccpy,memccpy@GLIBC_2.2.5"); +__asm__(".symver memchr,memchr@GLIBC_2.2.5"); +__asm__(".symver memcmp,memcmp@GLIBC_2.2.5"); +__asm__(".symver memcpy,memcpy@GLIBC_2.14"); +__asm__(".symver memfrob,memfrob@GLIBC_2.2.5"); +__asm__(".symver memmem,memmem@GLIBC_2.2.5"); +__asm__(".symver memmove,memmove@GLIBC_2.2.5"); +__asm__(".symver mempcpy,mempcpy@GLIBC_2.2.5"); +__asm__(".symver memrchr,memrchr@GLIBC_2.2.5"); +__asm__(".symver memset,memset@GLIBC_2.2.5"); +__asm__(".symver mincore,mincore@GLIBC_2.2.5"); +__asm__(".symver mkdir,mkdir@GLIBC_2.2.5"); +__asm__(".symver mkdirat,mkdirat@GLIBC_2.4"); +__asm__(".symver mkdtemp,mkdtemp@GLIBC_2.2.5"); +__asm__(".symver mkfifo,mkfifo@GLIBC_2.2.5"); +__asm__(".symver mkfifoat,mkfifoat@GLIBC_2.4"); +__asm__(".symver mkostemp,mkostemp@GLIBC_2.7"); +__asm__(".symver mkostemp64,mkostemp64@GLIBC_2.7"); +__asm__(".symver mkostemps,mkostemps@GLIBC_2.11"); +__asm__(".symver mkostemps64,mkostemps64@GLIBC_2.11"); +__asm__(".symver mkstemp,mkstemp@GLIBC_2.2.5"); +__asm__(".symver mkstemp64,mkstemp64@GLIBC_2.2.5"); +__asm__(".symver mkstemps,mkstemps@GLIBC_2.11"); +__asm__(".symver mkstemps64,mkstemps64@GLIBC_2.11"); +__asm__(".symver mktemp,mktemp@GLIBC_2.2.5"); +__asm__(".symver mktime,mktime@GLIBC_2.2.5"); +__asm__(".symver mlock,mlock@GLIBC_2.2.5"); +__asm__(".symver mlockall,mlockall@GLIBC_2.2.5"); +__asm__(".symver mmap,mmap@GLIBC_2.2.5"); +__asm__(".symver mmap64,mmap64@GLIBC_2.2.5"); +__asm__(".symver modf,modf@GLIBC_2.2.5"); +__asm__(".symver modff,modff@GLIBC_2.2.5"); +__asm__(".symver modfl,modfl@GLIBC_2.2.5"); +__asm__(".symver modify_ldt,modify_ldt@GLIBC_2.2.5"); +__asm__(".symver moncontrol,moncontrol@GLIBC_2.2.5"); +__asm__(".symver monstartup,monstartup@GLIBC_2.2.5"); +__asm__(".symver mount,mount@GLIBC_2.2.5"); +__asm__(".symver mprobe,mprobe@GLIBC_2.2.5"); +__asm__(".symver mprotect,mprotect@GLIBC_2.2.5"); +__asm__(".symver mq_close,mq_close@GLIBC_2.3.4"); +__asm__(".symver mq_getattr,mq_getattr@GLIBC_2.3.4"); +__asm__(".symver mq_notify,mq_notify@GLIBC_2.3.4"); +__asm__(".symver mq_open,mq_open@GLIBC_2.3.4"); +__asm__(".symver mq_receive,mq_receive@GLIBC_2.3.4"); +__asm__(".symver mq_send,mq_send@GLIBC_2.3.4"); +__asm__(".symver mq_setattr,mq_setattr@GLIBC_2.3.4"); +__asm__(".symver mq_timedreceive,mq_timedreceive@GLIBC_2.3.4"); +__asm__(".symver mq_timedsend,mq_timedsend@GLIBC_2.3.4"); +__asm__(".symver mq_unlink,mq_unlink@GLIBC_2.3.4"); +__asm__(".symver mrand48,mrand48@GLIBC_2.2.5"); +__asm__(".symver mrand48_r,mrand48_r@GLIBC_2.2.5"); +__asm__(".symver mremap,mremap@GLIBC_2.2.5"); +__asm__(".symver msgctl,msgctl@GLIBC_2.2.5"); +__asm__(".symver msgget,msgget@GLIBC_2.2.5"); +__asm__(".symver msgrcv,msgrcv@GLIBC_2.2.5"); +__asm__(".symver msgsnd,msgsnd@GLIBC_2.2.5"); +__asm__(".symver msync,msync@GLIBC_2.2.5"); +__asm__(".symver mtrace,mtrace@GLIBC_2.2.5"); +__asm__(".symver munlock,munlock@GLIBC_2.2.5"); +__asm__(".symver munlockall,munlockall@GLIBC_2.2.5"); +__asm__(".symver munmap,munmap@GLIBC_2.2.5"); +__asm__(".symver muntrace,muntrace@GLIBC_2.2.5"); +__asm__(".symver name_to_handle_at,name_to_handle_at@GLIBC_2.14"); +__asm__(".symver nan,nan@GLIBC_2.2.5"); +__asm__(".symver nanf,nanf@GLIBC_2.2.5"); +__asm__(".symver nanl,nanl@GLIBC_2.2.5"); +__asm__(".symver nanosleep,nanosleep@GLIBC_2.2.5"); +__asm__(".symver nearbyint,nearbyint@GLIBC_2.2.5"); +__asm__(".symver nearbyintf,nearbyintf@GLIBC_2.2.5"); +__asm__(".symver nearbyintl,nearbyintl@GLIBC_2.2.5"); +__asm__(".symver newlocale,newlocale@GLIBC_2.3"); +__asm__(".symver nextafter,nextafter@GLIBC_2.2.5"); +__asm__(".symver nextafterf,nextafterf@GLIBC_2.2.5"); +__asm__(".symver nextafterl,nextafterl@GLIBC_2.2.5"); +__asm__(".symver nexttoward,nexttoward@GLIBC_2.2.5"); +__asm__(".symver nexttowardf,nexttowardf@GLIBC_2.2.5"); +__asm__(".symver nexttowardl,nexttowardl@GLIBC_2.2.5"); +__asm__(".symver nfsservctl,nfsservctl@GLIBC_2.2.5"); +__asm__(".symver nftw,nftw@GLIBC_2.3.3"); +__asm__(".symver nftw64,nftw64@GLIBC_2.3.3"); +__asm__(".symver ngettext,ngettext@GLIBC_2.2.5"); +__asm__(".symver nice,nice@GLIBC_2.2.5"); +__asm__(".symver nis_add,nis_add@GLIBC_2.2.5"); +__asm__(".symver nis_add_entry,nis_add_entry@GLIBC_2.2.5"); +__asm__(".symver nis_addmember,nis_addmember@GLIBC_2.2.5"); +__asm__(".symver nis_checkpoint,nis_checkpoint@GLIBC_2.2.5"); +__asm__(".symver nis_clone_directory,nis_clone_directory@GLIBC_2.2.5"); +__asm__(".symver nis_clone_object,nis_clone_object@GLIBC_2.2.5"); +__asm__(".symver nis_clone_result,nis_clone_result@GLIBC_2.2.5"); +__asm__(".symver nis_creategroup,nis_creategroup@GLIBC_2.2.5"); +__asm__(".symver nis_destroy_object,nis_destroy_object@GLIBC_2.2.5"); +__asm__(".symver nis_destroygroup,nis_destroygroup@GLIBC_2.2.5"); +__asm__(".symver nis_dir_cmp,nis_dir_cmp@GLIBC_2.2.5"); +__asm__(".symver nis_domain_of,nis_domain_of@GLIBC_2.2.5"); +__asm__(".symver nis_domain_of_r,nis_domain_of_r@GLIBC_2.2.5"); +__asm__(".symver nis_first_entry,nis_first_entry@GLIBC_2.2.5"); +__asm__(".symver nis_free_directory,nis_free_directory@GLIBC_2.2.5"); +__asm__(".symver nis_free_object,nis_free_object@GLIBC_2.2.5"); +__asm__(".symver nis_free_request,nis_free_request@GLIBC_2.2.5"); +__asm__(".symver nis_freenames,nis_freenames@GLIBC_2.2.5"); +__asm__(".symver nis_freeresult,nis_freeresult@GLIBC_2.2.5"); +__asm__(".symver nis_freeservlist,nis_freeservlist@GLIBC_2.2.5"); +__asm__(".symver nis_freetags,nis_freetags@GLIBC_2.2.5"); +__asm__(".symver nis_getnames,nis_getnames@GLIBC_2.2.5"); +__asm__(".symver nis_getservlist,nis_getservlist@GLIBC_2.2.5"); +__asm__(".symver nis_ismember,nis_ismember@GLIBC_2.2.5"); +__asm__(".symver nis_leaf_of,nis_leaf_of@GLIBC_2.2.5"); +__asm__(".symver nis_leaf_of_r,nis_leaf_of_r@GLIBC_2.2.5"); +__asm__(".symver nis_lerror,nis_lerror@GLIBC_2.2.5"); +__asm__(".symver nis_list,nis_list@GLIBC_2.2.5"); +__asm__(".symver nis_local_directory,nis_local_directory@GLIBC_2.2.5"); +__asm__(".symver nis_local_group,nis_local_group@GLIBC_2.2.5"); +__asm__(".symver nis_local_host,nis_local_host@GLIBC_2.2.5"); +__asm__(".symver nis_local_principal,nis_local_principal@GLIBC_2.2.5"); +__asm__(".symver nis_lookup,nis_lookup@GLIBC_2.2.5"); +__asm__(".symver nis_mkdir,nis_mkdir@GLIBC_2.2.5"); +__asm__(".symver nis_modify,nis_modify@GLIBC_2.2.5"); +__asm__(".symver nis_modify_entry,nis_modify_entry@GLIBC_2.2.5"); +__asm__(".symver nis_name_of,nis_name_of@GLIBC_2.2.5"); +__asm__(".symver nis_name_of_r,nis_name_of_r@GLIBC_2.2.5"); +__asm__(".symver nis_next_entry,nis_next_entry@GLIBC_2.2.5"); +__asm__(".symver nis_perror,nis_perror@GLIBC_2.2.5"); +__asm__(".symver nis_ping,nis_ping@GLIBC_2.2.5"); +__asm__(".symver nis_print_directory,nis_print_directory@GLIBC_2.2.5"); +__asm__(".symver nis_print_entry,nis_print_entry@GLIBC_2.2.5"); +__asm__(".symver nis_print_group,nis_print_group@GLIBC_2.2.5"); +__asm__(".symver nis_print_group_entry,nis_print_group_entry@GLIBC_2.2.5"); +__asm__(".symver nis_print_link,nis_print_link@GLIBC_2.2.5"); +__asm__(".symver nis_print_object,nis_print_object@GLIBC_2.2.5"); +__asm__(".symver nis_print_result,nis_print_result@GLIBC_2.2.5"); +__asm__(".symver nis_print_rights,nis_print_rights@GLIBC_2.2.5"); +__asm__(".symver nis_print_table,nis_print_table@GLIBC_2.2.5"); +__asm__(".symver nis_read_obj,nis_read_obj@GLIBC_2.2.5"); +__asm__(".symver nis_remove,nis_remove@GLIBC_2.2.5"); +__asm__(".symver nis_remove_entry,nis_remove_entry@GLIBC_2.2.5"); +__asm__(".symver nis_removemember,nis_removemember@GLIBC_2.2.5"); +__asm__(".symver nis_rmdir,nis_rmdir@GLIBC_2.2.5"); +__asm__(".symver nis_servstate,nis_servstate@GLIBC_2.2.5"); +__asm__(".symver nis_sperrno,nis_sperrno@GLIBC_2.2.5"); +__asm__(".symver nis_sperror,nis_sperror@GLIBC_2.2.5"); +__asm__(".symver nis_sperror_r,nis_sperror_r@GLIBC_2.2.5"); +__asm__(".symver nis_stats,nis_stats@GLIBC_2.2.5"); +__asm__(".symver nis_verifygroup,nis_verifygroup@GLIBC_2.2.5"); +__asm__(".symver nis_write_obj,nis_write_obj@GLIBC_2.2.5"); +__asm__(".symver nl_langinfo,nl_langinfo@GLIBC_2.2.5"); +__asm__(".symver nl_langinfo_l,nl_langinfo_l@GLIBC_2.3"); +__asm__(".symver nrand48,nrand48@GLIBC_2.2.5"); +__asm__(".symver nrand48_r,nrand48_r@GLIBC_2.2.5"); +__asm__(".symver ns_datetosecs,ns_datetosecs@GLIBC_2.9"); +__asm__(".symver ns_format_ttl,ns_format_ttl@GLIBC_2.9"); +__asm__(".symver ns_get16,ns_get16@GLIBC_2.9"); +__asm__(".symver ns_get32,ns_get32@GLIBC_2.9"); +__asm__(".symver ns_initparse,ns_initparse@GLIBC_2.9"); +__asm__(".symver ns_makecanon,ns_makecanon@GLIBC_2.9"); +__asm__(".symver ns_msg_getflag,ns_msg_getflag@GLIBC_2.9"); +__asm__(".symver ns_name_compress,ns_name_compress@GLIBC_2.9"); +__asm__(".symver ns_name_ntol,ns_name_ntol@GLIBC_2.9"); +__asm__(".symver ns_name_ntop,ns_name_ntop@GLIBC_2.9"); +__asm__(".symver ns_name_pack,ns_name_pack@GLIBC_2.9"); +__asm__(".symver ns_name_pton,ns_name_pton@GLIBC_2.9"); +__asm__(".symver ns_name_rollback,ns_name_rollback@GLIBC_2.9"); +__asm__(".symver ns_name_skip,ns_name_skip@GLIBC_2.9"); +__asm__(".symver ns_name_uncompress,ns_name_uncompress@GLIBC_2.9"); +__asm__(".symver ns_name_unpack,ns_name_unpack@GLIBC_2.9"); +__asm__(".symver ns_parse_ttl,ns_parse_ttl@GLIBC_2.9"); +__asm__(".symver ns_parserr,ns_parserr@GLIBC_2.9"); +__asm__(".symver ns_put16,ns_put16@GLIBC_2.9"); +__asm__(".symver ns_put32,ns_put32@GLIBC_2.9"); +__asm__(".symver ns_samedomain,ns_samedomain@GLIBC_2.9"); +__asm__(".symver ns_samename,ns_samename@GLIBC_2.9"); +__asm__(".symver ns_skiprr,ns_skiprr@GLIBC_2.9"); +__asm__(".symver ns_sprintrr,ns_sprintrr@GLIBC_2.9"); +__asm__(".symver ns_sprintrrf,ns_sprintrrf@GLIBC_2.9"); +__asm__(".symver ns_subdomain,ns_subdomain@GLIBC_2.9"); +__asm__(".symver ntohl,ntohl@GLIBC_2.2.5"); +__asm__(".symver ntohs,ntohs@GLIBC_2.2.5"); +__asm__(".symver ntp_adjtime,ntp_adjtime@GLIBC_2.2.5"); +__asm__(".symver ntp_gettime,ntp_gettime@GLIBC_2.2.5"); +__asm__(".symver ntp_gettimex,ntp_gettimex@GLIBC_2.12"); +__asm__(".symver obstack_alloc_failed_handler,obstack_alloc_failed_handler@GLIBC_2.2.5"); +__asm__(".symver obstack_exit_failure,obstack_exit_failure@GLIBC_2.2.5"); +__asm__(".symver obstack_free,obstack_free@GLIBC_2.2.5"); +__asm__(".symver obstack_printf,obstack_printf@GLIBC_2.2.5"); +__asm__(".symver obstack_vprintf,obstack_vprintf@GLIBC_2.2.5"); +__asm__(".symver on_exit,on_exit@GLIBC_2.2.5"); +__asm__(".symver open,open@GLIBC_2.2.5"); +__asm__(".symver open64,open64@GLIBC_2.2.5"); +__asm__(".symver open_by_handle_at,open_by_handle_at@GLIBC_2.14"); +__asm__(".symver open_memstream,open_memstream@GLIBC_2.2.5"); +__asm__(".symver open_wmemstream,open_wmemstream@GLIBC_2.4"); +__asm__(".symver openat,openat@GLIBC_2.4"); +__asm__(".symver openat64,openat64@GLIBC_2.4"); +__asm__(".symver opendir,opendir@GLIBC_2.2.5"); +__asm__(".symver openlog,openlog@GLIBC_2.2.5"); +__asm__(".symver openpty,openpty@GLIBC_2.2.5"); +__asm__(".symver optarg,optarg@GLIBC_2.2.5"); +__asm__(".symver opterr,opterr@GLIBC_2.2.5"); +__asm__(".symver optind,optind@GLIBC_2.2.5"); +__asm__(".symver optopt,optopt@GLIBC_2.2.5"); +__asm__(".symver parse_printf_format,parse_printf_format@GLIBC_2.2.5"); +__asm__(".symver pathconf,pathconf@GLIBC_2.2.5"); +__asm__(".symver pause,pause@GLIBC_2.2.5"); +__asm__(".symver pclose,pclose@GLIBC_2.2.5"); +__asm__(".symver perror,perror@GLIBC_2.2.5"); +__asm__(".symver personality,personality@GLIBC_2.2.5"); +__asm__(".symver pipe,pipe@GLIBC_2.2.5"); +__asm__(".symver pipe2,pipe2@GLIBC_2.9"); +__asm__(".symver pivot_root,pivot_root@GLIBC_2.2.5"); +__asm__(".symver poll,poll@GLIBC_2.2.5"); +__asm__(".symver popen,popen@GLIBC_2.2.5"); +__asm__(".symver posix_fadvise,posix_fadvise@GLIBC_2.2.5"); +__asm__(".symver posix_fadvise64,posix_fadvise64@GLIBC_2.2.5"); +__asm__(".symver posix_fallocate,posix_fallocate@GLIBC_2.2.5"); +__asm__(".symver posix_fallocate64,posix_fallocate64@GLIBC_2.2.5"); +__asm__(".symver posix_madvise,posix_madvise@GLIBC_2.2.5"); +__asm__(".symver posix_memalign,posix_memalign@GLIBC_2.2.5"); +__asm__(".symver posix_openpt,posix_openpt@GLIBC_2.2.5"); +__asm__(".symver posix_spawn,posix_spawn@GLIBC_2.15"); +__asm__(".symver posix_spawn_file_actions_addclose,posix_spawn_file_actions_addclose@GLIBC_2.2.5"); +__asm__(".symver posix_spawn_file_actions_adddup2,posix_spawn_file_actions_adddup2@GLIBC_2.2.5"); +__asm__(".symver posix_spawn_file_actions_addopen,posix_spawn_file_actions_addopen@GLIBC_2.2.5"); +__asm__(".symver posix_spawn_file_actions_destroy,posix_spawn_file_actions_destroy@GLIBC_2.2.5"); +__asm__(".symver posix_spawn_file_actions_init,posix_spawn_file_actions_init@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_destroy,posix_spawnattr_destroy@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_getflags,posix_spawnattr_getflags@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_getpgroup,posix_spawnattr_getpgroup@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_getschedparam,posix_spawnattr_getschedparam@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_getschedpolicy,posix_spawnattr_getschedpolicy@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_getsigdefault,posix_spawnattr_getsigdefault@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_getsigmask,posix_spawnattr_getsigmask@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_init,posix_spawnattr_init@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_setflags,posix_spawnattr_setflags@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_setpgroup,posix_spawnattr_setpgroup@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_setschedparam,posix_spawnattr_setschedparam@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_setschedpolicy,posix_spawnattr_setschedpolicy@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_setsigdefault,posix_spawnattr_setsigdefault@GLIBC_2.2.5"); +__asm__(".symver posix_spawnattr_setsigmask,posix_spawnattr_setsigmask@GLIBC_2.2.5"); +__asm__(".symver posix_spawnp,posix_spawnp@GLIBC_2.15"); +__asm__(".symver pow,pow@GLIBC_2.2.5"); +__asm__(".symver pow10,pow10@GLIBC_2.2.5"); +__asm__(".symver pow10f,pow10f@GLIBC_2.2.5"); +__asm__(".symver pow10l,pow10l@GLIBC_2.2.5"); +__asm__(".symver powf,powf@GLIBC_2.2.5"); +__asm__(".symver powl,powl@GLIBC_2.2.5"); +__asm__(".symver ppoll,ppoll@GLIBC_2.4"); +__asm__(".symver prctl,prctl@GLIBC_2.2.5"); +__asm__(".symver pread,pread@GLIBC_2.2.5"); +__asm__(".symver pread64,pread64@GLIBC_2.2.5"); +__asm__(".symver preadv,preadv@GLIBC_2.10"); +__asm__(".symver preadv64,preadv64@GLIBC_2.10"); +__asm__(".symver printf,printf@GLIBC_2.2.5"); +__asm__(".symver printf_size,printf_size@GLIBC_2.2.5"); +__asm__(".symver printf_size_info,printf_size_info@GLIBC_2.2.5"); +__asm__(".symver prlimit,prlimit@GLIBC_2.13"); +__asm__(".symver prlimit64,prlimit64@GLIBC_2.13"); +__asm__(".symver process_vm_readv,process_vm_readv@GLIBC_2.15"); +__asm__(".symver process_vm_writev,process_vm_writev@GLIBC_2.15"); +__asm__(".symver profil,profil@GLIBC_2.2.5"); +__asm__(".symver program_invocation_name,program_invocation_name@GLIBC_2.2.5"); +__asm__(".symver program_invocation_short_name,program_invocation_short_name@GLIBC_2.2.5"); +__asm__(".symver pselect,pselect@GLIBC_2.2.5"); +__asm__(".symver psiginfo,psiginfo@GLIBC_2.10"); +__asm__(".symver psignal,psignal@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_attr_destroy,pthread_attr_destroy@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_attr_getaffinity_np,pthread_attr_getaffinity_np@GLIBC_2.3.4"); +#ifdef _REENTRANT +__asm__(".symver pthread_attr_getdetachstate,pthread_attr_getdetachstate@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_attr_getguardsize,pthread_attr_getguardsize@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_attr_getinheritsched,pthread_attr_getinheritsched@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_attr_getschedparam,pthread_attr_getschedparam@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_attr_getschedpolicy,pthread_attr_getschedpolicy@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_attr_getscope,pthread_attr_getscope@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_attr_getstack,pthread_attr_getstack@GLIBC_2.2.5"); +__asm__(".symver pthread_attr_getstackaddr,pthread_attr_getstackaddr@GLIBC_2.2.5"); +__asm__(".symver pthread_attr_getstacksize,pthread_attr_getstacksize@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_attr_init,pthread_attr_init@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_attr_setaffinity_np,pthread_attr_setaffinity_np@GLIBC_2.3.4"); +#ifdef _REENTRANT +__asm__(".symver pthread_attr_setdetachstate,pthread_attr_setdetachstate@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_attr_setguardsize,pthread_attr_setguardsize@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_attr_setinheritsched,pthread_attr_setinheritsched@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_attr_setschedparam,pthread_attr_setschedparam@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_attr_setschedpolicy,pthread_attr_setschedpolicy@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_attr_setscope,pthread_attr_setscope@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_attr_setstack,pthread_attr_setstack@GLIBC_2.2.5"); +__asm__(".symver pthread_attr_setstackaddr,pthread_attr_setstackaddr@GLIBC_2.2.5"); +__asm__(".symver pthread_attr_setstacksize,pthread_attr_setstacksize@GLIBC_2.2.5"); +__asm__(".symver pthread_barrier_destroy,pthread_barrier_destroy@GLIBC_2.2.5"); +__asm__(".symver pthread_barrier_init,pthread_barrier_init@GLIBC_2.2.5"); +__asm__(".symver pthread_barrier_wait,pthread_barrier_wait@GLIBC_2.2.5"); +__asm__(".symver pthread_barrierattr_destroy,pthread_barrierattr_destroy@GLIBC_2.2.5"); +__asm__(".symver pthread_barrierattr_getpshared,pthread_barrierattr_getpshared@GLIBC_2.3.3"); +__asm__(".symver pthread_barrierattr_init,pthread_barrierattr_init@GLIBC_2.2.5"); +__asm__(".symver pthread_barrierattr_setpshared,pthread_barrierattr_setpshared@GLIBC_2.2.5"); +__asm__(".symver pthread_cancel,pthread_cancel@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_cond_broadcast,pthread_cond_broadcast@GLIBC_2.3.2"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_cond_destroy,pthread_cond_destroy@GLIBC_2.3.2"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_cond_init,pthread_cond_init@GLIBC_2.3.2"); +#endif +__asm__(".symver pthread_cond_signal,pthread_cond_signal@GLIBC_2.3.2"); +#ifdef _REENTRANT +__asm__(".symver pthread_cond_timedwait,pthread_cond_timedwait@GLIBC_2.3.2"); +#endif +__asm__(".symver pthread_cond_wait,pthread_cond_wait@GLIBC_2.3.2"); +#ifdef _REENTRANT +__asm__(".symver pthread_condattr_destroy,pthread_condattr_destroy@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_condattr_getclock,pthread_condattr_getclock@GLIBC_2.3.3"); +__asm__(".symver pthread_condattr_getpshared,pthread_condattr_getpshared@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_condattr_init,pthread_condattr_init@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_condattr_setclock,pthread_condattr_setclock@GLIBC_2.3.3"); +__asm__(".symver pthread_condattr_setpshared,pthread_condattr_setpshared@GLIBC_2.2.5"); +#ifndef _GLIBCXX_SHARED +#ifdef _REENTRANT +__asm__(".symver pthread_create,pthread_create@GLIBC_2.2.5"); +#endif +#endif +#ifndef _GLIBCXX_SHARED +#ifdef _REENTRANT +__asm__(".symver pthread_detach,pthread_detach@GLIBC_2.2.5"); +#endif +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_equal,pthread_equal@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_exit,pthread_exit@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_getaffinity_np,pthread_getaffinity_np@GLIBC_2.3.4"); +__asm__(".symver pthread_getattr_default_np,pthread_getattr_default_np@GLIBC_2.18"); +__asm__(".symver pthread_getattr_np,pthread_getattr_np@GLIBC_2.2.5"); +__asm__(".symver pthread_getconcurrency,pthread_getconcurrency@GLIBC_2.2.5"); +__asm__(".symver pthread_getcpuclockid,pthread_getcpuclockid@GLIBC_2.2.5"); +__asm__(".symver pthread_getname_np,pthread_getname_np@GLIBC_2.12"); +#ifdef _REENTRANT +__asm__(".symver pthread_getschedparam,pthread_getschedparam@GLIBC_2.2.5"); +#endif +#ifndef _GLIBCXX_SHARED +#ifndef IN_LIBGCC2 +#ifdef _REENTRANT +__asm__(".symver pthread_getspecific,pthread_getspecific@GLIBC_2.2.5"); +#endif +#endif +#endif +#ifndef _GLIBCXX_SHARED +#ifdef _REENTRANT +__asm__(".symver pthread_join,pthread_join@GLIBC_2.2.5"); +#endif +#endif +#ifndef _GLIBCXX_SHARED +#ifndef IN_LIBGCC2 +#ifdef _REENTRANT +__asm__(".symver pthread_key_create,pthread_key_create@GLIBC_2.2.5"); +#endif +#endif +#endif +#ifndef _GLIBCXX_SHARED +#ifdef _REENTRANT +__asm__(".symver pthread_key_delete,pthread_key_delete@GLIBC_2.2.5"); +#endif +#endif +__asm__(".symver pthread_kill,pthread_kill@GLIBC_2.2.5"); +__asm__(".symver pthread_mutex_consistent,pthread_mutex_consistent@GLIBC_2.12"); +__asm__(".symver pthread_mutex_consistent_np,pthread_mutex_consistent_np@GLIBC_2.4"); +#ifdef _REENTRANT +__asm__(".symver pthread_mutex_destroy,pthread_mutex_destroy@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_mutex_getprioceiling,pthread_mutex_getprioceiling@GLIBC_2.4"); +#ifdef _REENTRANT +__asm__(".symver pthread_mutex_init,pthread_mutex_init@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_mutex_lock,pthread_mutex_lock@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_mutex_setprioceiling,pthread_mutex_setprioceiling@GLIBC_2.4"); +__asm__(".symver pthread_mutex_timedlock,pthread_mutex_timedlock@GLIBC_2.2.5"); +__asm__(".symver pthread_mutex_trylock,pthread_mutex_trylock@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_mutex_unlock,pthread_mutex_unlock@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_mutexattr_destroy,pthread_mutexattr_destroy@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_getkind_np,pthread_mutexattr_getkind_np@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_getprioceiling,pthread_mutexattr_getprioceiling@GLIBC_2.4"); +__asm__(".symver pthread_mutexattr_getprotocol,pthread_mutexattr_getprotocol@GLIBC_2.4"); +__asm__(".symver pthread_mutexattr_getpshared,pthread_mutexattr_getpshared@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_getrobust,pthread_mutexattr_getrobust@GLIBC_2.12"); +__asm__(".symver pthread_mutexattr_getrobust_np,pthread_mutexattr_getrobust_np@GLIBC_2.4"); +__asm__(".symver pthread_mutexattr_gettype,pthread_mutexattr_gettype@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_init,pthread_mutexattr_init@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_setkind_np,pthread_mutexattr_setkind_np@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_setprioceiling,pthread_mutexattr_setprioceiling@GLIBC_2.4"); +__asm__(".symver pthread_mutexattr_setprotocol,pthread_mutexattr_setprotocol@GLIBC_2.4"); +__asm__(".symver pthread_mutexattr_setpshared,pthread_mutexattr_setpshared@GLIBC_2.2.5"); +__asm__(".symver pthread_mutexattr_setrobust,pthread_mutexattr_setrobust@GLIBC_2.12"); +__asm__(".symver pthread_mutexattr_setrobust_np,pthread_mutexattr_setrobust_np@GLIBC_2.4"); +__asm__(".symver pthread_mutexattr_settype,pthread_mutexattr_settype@GLIBC_2.2.5"); +#ifndef _GLIBCXX_SHARED +#ifndef IN_LIBGCC2 +#ifdef _REENTRANT +__asm__(".symver pthread_once,pthread_once@GLIBC_2.2.5"); +#endif +#endif +#endif +__asm__(".symver pthread_rwlock_destroy,pthread_rwlock_destroy@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_init,pthread_rwlock_init@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_rdlock,pthread_rwlock_rdlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_timedrdlock,pthread_rwlock_timedrdlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_timedwrlock,pthread_rwlock_timedwrlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_tryrdlock,pthread_rwlock_tryrdlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_trywrlock,pthread_rwlock_trywrlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_unlock,pthread_rwlock_unlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlock_wrlock,pthread_rwlock_wrlock@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlockattr_destroy,pthread_rwlockattr_destroy@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlockattr_getkind_np,pthread_rwlockattr_getkind_np@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlockattr_getpshared,pthread_rwlockattr_getpshared@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlockattr_init,pthread_rwlockattr_init@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlockattr_setkind_np,pthread_rwlockattr_setkind_np@GLIBC_2.2.5"); +__asm__(".symver pthread_rwlockattr_setpshared,pthread_rwlockattr_setpshared@GLIBC_2.2.5"); +#ifdef _REENTRANT +__asm__(".symver pthread_self,pthread_self@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_setaffinity_np,pthread_setaffinity_np@GLIBC_2.3.4"); +__asm__(".symver pthread_setattr_default_np,pthread_setattr_default_np@GLIBC_2.18"); +#ifdef _REENTRANT +__asm__(".symver pthread_setcancelstate,pthread_setcancelstate@GLIBC_2.2.5"); +#endif +#ifdef _REENTRANT +__asm__(".symver pthread_setcanceltype,pthread_setcanceltype@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_setconcurrency,pthread_setconcurrency@GLIBC_2.2.5"); +__asm__(".symver pthread_setname_np,pthread_setname_np@GLIBC_2.12"); +#ifdef _REENTRANT +__asm__(".symver pthread_setschedparam,pthread_setschedparam@GLIBC_2.2.5"); +#endif +__asm__(".symver pthread_setschedprio,pthread_setschedprio@GLIBC_2.3.4"); +#ifndef _GLIBCXX_SHARED +#ifndef IN_LIBGCC2 +#ifdef _REENTRANT +__asm__(".symver pthread_setspecific,pthread_setspecific@GLIBC_2.2.5"); +#endif +#endif +#endif +__asm__(".symver pthread_sigmask,pthread_sigmask@GLIBC_2.2.5"); +__asm__(".symver pthread_sigqueue,pthread_sigqueue@GLIBC_2.11"); +__asm__(".symver pthread_spin_destroy,pthread_spin_destroy@GLIBC_2.2.5"); +__asm__(".symver pthread_spin_init,pthread_spin_init@GLIBC_2.2.5"); +__asm__(".symver pthread_spin_lock,pthread_spin_lock@GLIBC_2.2.5"); +__asm__(".symver pthread_spin_trylock,pthread_spin_trylock@GLIBC_2.2.5"); +__asm__(".symver pthread_spin_unlock,pthread_spin_unlock@GLIBC_2.2.5"); +__asm__(".symver pthread_testcancel,pthread_testcancel@GLIBC_2.2.5"); +__asm__(".symver pthread_timedjoin_np,pthread_timedjoin_np@GLIBC_2.3.3"); +__asm__(".symver pthread_tryjoin_np,pthread_tryjoin_np@GLIBC_2.3.3"); +__asm__(".symver pthread_yield,pthread_yield@GLIBC_2.2.5"); +__asm__(".symver ptrace,ptrace@GLIBC_2.2.5"); +__asm__(".symver ptsname,ptsname@GLIBC_2.2.5"); +__asm__(".symver ptsname_r,ptsname_r@GLIBC_2.2.5"); +__asm__(".symver putc,putc@GLIBC_2.2.5"); +__asm__(".symver putc_unlocked,putc_unlocked@GLIBC_2.2.5"); +__asm__(".symver putchar,putchar@GLIBC_2.2.5"); +__asm__(".symver putchar_unlocked,putchar_unlocked@GLIBC_2.2.5"); +__asm__(".symver putenv,putenv@GLIBC_2.2.5"); +__asm__(".symver putgrent,putgrent@GLIBC_2.2.5"); +__asm__(".symver putmsg,putmsg@GLIBC_2.2.5"); +__asm__(".symver putpmsg,putpmsg@GLIBC_2.2.5"); +__asm__(".symver putpwent,putpwent@GLIBC_2.2.5"); +__asm__(".symver puts,puts@GLIBC_2.2.5"); +__asm__(".symver putsgent,putsgent@GLIBC_2.10"); +__asm__(".symver putspent,putspent@GLIBC_2.2.5"); +__asm__(".symver pututline,pututline@GLIBC_2.2.5"); +__asm__(".symver pututxline,pututxline@GLIBC_2.2.5"); +__asm__(".symver putw,putw@GLIBC_2.2.5"); +__asm__(".symver putwc,putwc@GLIBC_2.2.5"); +__asm__(".symver putwc_unlocked,putwc_unlocked@GLIBC_2.2.5"); +__asm__(".symver putwchar,putwchar@GLIBC_2.2.5"); +__asm__(".symver putwchar_unlocked,putwchar_unlocked@GLIBC_2.2.5"); +__asm__(".symver pvalloc,pvalloc@GLIBC_2.2.5"); +__asm__(".symver pwrite,pwrite@GLIBC_2.2.5"); +__asm__(".symver pwrite64,pwrite64@GLIBC_2.2.5"); +__asm__(".symver pwritev,pwritev@GLIBC_2.10"); +__asm__(".symver pwritev64,pwritev64@GLIBC_2.10"); +__asm__(".symver qecvt,qecvt@GLIBC_2.2.5"); +__asm__(".symver qecvt_r,qecvt_r@GLIBC_2.2.5"); +__asm__(".symver qfcvt,qfcvt@GLIBC_2.2.5"); +__asm__(".symver qfcvt_r,qfcvt_r@GLIBC_2.2.5"); +__asm__(".symver qgcvt,qgcvt@GLIBC_2.2.5"); +__asm__(".symver qsort,qsort@GLIBC_2.2.5"); +__asm__(".symver qsort_r,qsort_r@GLIBC_2.8"); +__asm__(".symver quick_exit,quick_exit@GLIBC_2.10"); +__asm__(".symver quotactl,quotactl@GLIBC_2.2.5"); +__asm__(".symver raise,raise@GLIBC_2.2.5"); +__asm__(".symver rand,rand@GLIBC_2.2.5"); +__asm__(".symver rand_r,rand_r@GLIBC_2.2.5"); +__asm__(".symver random,random@GLIBC_2.2.5"); +__asm__(".symver random_r,random_r@GLIBC_2.2.5"); +__asm__(".symver rawmemchr,rawmemchr@GLIBC_2.2.5"); +__asm__(".symver rcmd,rcmd@GLIBC_2.2.5"); +__asm__(".symver rcmd_af,rcmd_af@GLIBC_2.2.5"); +__asm__(".symver re_comp,re_comp@GLIBC_2.2.5"); +__asm__(".symver re_compile_fastmap,re_compile_fastmap@GLIBC_2.2.5"); +__asm__(".symver re_compile_pattern,re_compile_pattern@GLIBC_2.2.5"); +__asm__(".symver re_exec,re_exec@GLIBC_2.2.5"); +__asm__(".symver re_match,re_match@GLIBC_2.2.5"); +__asm__(".symver re_match_2,re_match_2@GLIBC_2.2.5"); +__asm__(".symver re_max_failures,re_max_failures@GLIBC_2.2.5"); +__asm__(".symver re_search,re_search@GLIBC_2.2.5"); +__asm__(".symver re_search_2,re_search_2@GLIBC_2.2.5"); +__asm__(".symver re_set_registers,re_set_registers@GLIBC_2.2.5"); +__asm__(".symver re_set_syntax,re_set_syntax@GLIBC_2.2.5"); +__asm__(".symver re_syntax_options,re_syntax_options@GLIBC_2.2.5"); +__asm__(".symver read,read@GLIBC_2.2.5"); +__asm__(".symver readColdStartFile,readColdStartFile@GLIBC_2.2.5"); +__asm__(".symver readahead,readahead@GLIBC_2.3"); +__asm__(".symver readdir,readdir@GLIBC_2.2.5"); +__asm__(".symver readdir64,readdir64@GLIBC_2.2.5"); +__asm__(".symver readdir64_r,readdir64_r@GLIBC_2.2.5"); +__asm__(".symver readdir_r,readdir_r@GLIBC_2.2.5"); +__asm__(".symver readlink,readlink@GLIBC_2.2.5"); +__asm__(".symver readlinkat,readlinkat@GLIBC_2.4"); +__asm__(".symver readv,readv@GLIBC_2.2.5"); +__asm__(".symver realloc,realloc@GLIBC_2.2.5"); +__asm__(".symver realpath,realpath@GLIBC_2.3"); +__asm__(".symver reboot,reboot@GLIBC_2.2.5"); +__asm__(".symver recv,recv@GLIBC_2.2.5"); +__asm__(".symver recvfrom,recvfrom@GLIBC_2.2.5"); +__asm__(".symver recvmmsg,recvmmsg@GLIBC_2.12"); +__asm__(".symver recvmsg,recvmsg@GLIBC_2.2.5"); +__asm__(".symver regcomp,regcomp@GLIBC_2.2.5"); +__asm__(".symver regerror,regerror@GLIBC_2.2.5"); +__asm__(".symver regexec,regexec@GLIBC_2.3.4"); +__asm__(".symver regfree,regfree@GLIBC_2.2.5"); +__asm__(".symver register_printf_function,register_printf_function@GLIBC_2.2.5"); +__asm__(".symver register_printf_modifier,register_printf_modifier@GLIBC_2.10"); +__asm__(".symver register_printf_specifier,register_printf_specifier@GLIBC_2.10"); +__asm__(".symver register_printf_type,register_printf_type@GLIBC_2.10"); +__asm__(".symver remainder,remainder@GLIBC_2.2.5"); +__asm__(".symver remainderf,remainderf@GLIBC_2.2.5"); +__asm__(".symver remainderl,remainderl@GLIBC_2.2.5"); +__asm__(".symver remap_file_pages,remap_file_pages@GLIBC_2.3.3"); +__asm__(".symver remove,remove@GLIBC_2.2.5"); +__asm__(".symver removexattr,removexattr@GLIBC_2.3"); +__asm__(".symver remque,remque@GLIBC_2.2.5"); +__asm__(".symver remquo,remquo@GLIBC_2.2.5"); +__asm__(".symver remquof,remquof@GLIBC_2.2.5"); +__asm__(".symver remquol,remquol@GLIBC_2.2.5"); +__asm__(".symver rename,rename@GLIBC_2.2.5"); +__asm__(".symver renameat,renameat@GLIBC_2.4"); +__asm__(".symver res_gethostbyaddr,res_gethostbyaddr@GLIBC_2.2.5"); +__asm__(".symver res_gethostbyname,res_gethostbyname@GLIBC_2.2.5"); +__asm__(".symver res_gethostbyname2,res_gethostbyname2@GLIBC_2.2.5"); +__asm__(".symver res_send_setqhook,res_send_setqhook@GLIBC_2.2.5"); +__asm__(".symver res_send_setrhook,res_send_setrhook@GLIBC_2.2.5"); +__asm__(".symver revoke,revoke@GLIBC_2.2.5"); +__asm__(".symver rewind,rewind@GLIBC_2.2.5"); +__asm__(".symver rewinddir,rewinddir@GLIBC_2.2.5"); +__asm__(".symver rexec,rexec@GLIBC_2.2.5"); +__asm__(".symver rexec_af,rexec_af@GLIBC_2.2.5"); +__asm__(".symver rexecoptions,rexecoptions@GLIBC_2.2.5"); +__asm__(".symver rindex,rindex@GLIBC_2.2.5"); +__asm__(".symver rint,rint@GLIBC_2.2.5"); +__asm__(".symver rintf,rintf@GLIBC_2.2.5"); +__asm__(".symver rintl,rintl@GLIBC_2.2.5"); +__asm__(".symver rmdir,rmdir@GLIBC_2.2.5"); +__asm__(".symver round,round@GLIBC_2.2.5"); +__asm__(".symver roundf,roundf@GLIBC_2.2.5"); +__asm__(".symver roundl,roundl@GLIBC_2.2.5"); +__asm__(".symver rpc_createerr,rpc_createerr@GLIBC_2.2.5"); +__asm__(".symver rpmatch,rpmatch@GLIBC_2.2.5"); +__asm__(".symver rresvport,rresvport@GLIBC_2.2.5"); +__asm__(".symver rresvport_af,rresvport_af@GLIBC_2.2.5"); +__asm__(".symver ruserok,ruserok@GLIBC_2.2.5"); +__asm__(".symver ruserok_af,ruserok_af@GLIBC_2.2.5"); +__asm__(".symver ruserpass,ruserpass@GLIBC_2.2.5"); +__asm__(".symver sbrk,sbrk@GLIBC_2.2.5"); +__asm__(".symver scalb,scalb@GLIBC_2.2.5"); +__asm__(".symver scalbf,scalbf@GLIBC_2.2.5"); +__asm__(".symver scalbl,scalbl@GLIBC_2.2.5"); +__asm__(".symver scalbln,scalbln@GLIBC_2.2.5"); +__asm__(".symver scalblnf,scalblnf@GLIBC_2.2.5"); +__asm__(".symver scalblnl,scalblnl@GLIBC_2.2.5"); +__asm__(".symver scalbn,scalbn@GLIBC_2.2.5"); +__asm__(".symver scalbnf,scalbnf@GLIBC_2.2.5"); +__asm__(".symver scalbnl,scalbnl@GLIBC_2.2.5"); +__asm__(".symver scandir,scandir@GLIBC_2.2.5"); +__asm__(".symver scandir64,scandir64@GLIBC_2.2.5"); +__asm__(".symver scandirat,scandirat@GLIBC_2.15"); +__asm__(".symver scandirat64,scandirat64@GLIBC_2.15"); +__asm__(".symver scanf,scanf@GLIBC_2.2.5"); +__asm__(".symver sched_get_priority_max,sched_get_priority_max@GLIBC_2.2.5"); +__asm__(".symver sched_get_priority_min,sched_get_priority_min@GLIBC_2.2.5"); +__asm__(".symver sched_getaffinity,sched_getaffinity@GLIBC_2.3.4"); +__asm__(".symver sched_getcpu,sched_getcpu@GLIBC_2.6"); +__asm__(".symver sched_getparam,sched_getparam@GLIBC_2.2.5"); +__asm__(".symver sched_getscheduler,sched_getscheduler@GLIBC_2.2.5"); +__asm__(".symver sched_rr_get_interval,sched_rr_get_interval@GLIBC_2.2.5"); +__asm__(".symver sched_setaffinity,sched_setaffinity@GLIBC_2.3.4"); +__asm__(".symver sched_setparam,sched_setparam@GLIBC_2.2.5"); +__asm__(".symver sched_setscheduler,sched_setscheduler@GLIBC_2.2.5"); +__asm__(".symver sched_yield,sched_yield@GLIBC_2.2.5"); +__asm__(".symver secure_getenv,secure_getenv@GLIBC_2.17"); +__asm__(".symver seed48,seed48@GLIBC_2.2.5"); +__asm__(".symver seed48_r,seed48_r@GLIBC_2.2.5"); +__asm__(".symver seekdir,seekdir@GLIBC_2.2.5"); +__asm__(".symver select,select@GLIBC_2.2.5"); +__asm__(".symver sem_close,sem_close@GLIBC_2.2.5"); +__asm__(".symver sem_destroy,sem_destroy@GLIBC_2.2.5"); +__asm__(".symver sem_getvalue,sem_getvalue@GLIBC_2.2.5"); +__asm__(".symver sem_init,sem_init@GLIBC_2.2.5"); +__asm__(".symver sem_open,sem_open@GLIBC_2.2.5"); +__asm__(".symver sem_post,sem_post@GLIBC_2.2.5"); +__asm__(".symver sem_timedwait,sem_timedwait@GLIBC_2.2.5"); +__asm__(".symver sem_trywait,sem_trywait@GLIBC_2.2.5"); +__asm__(".symver sem_unlink,sem_unlink@GLIBC_2.2.5"); +__asm__(".symver sem_wait,sem_wait@GLIBC_2.2.5"); +__asm__(".symver semctl,semctl@GLIBC_2.2.5"); +__asm__(".symver semget,semget@GLIBC_2.2.5"); +__asm__(".symver semop,semop@GLIBC_2.2.5"); +__asm__(".symver semtimedop,semtimedop@GLIBC_2.3.3"); +__asm__(".symver send,send@GLIBC_2.2.5"); +__asm__(".symver sendfile,sendfile@GLIBC_2.2.5"); +__asm__(".symver sendfile64,sendfile64@GLIBC_2.3"); +__asm__(".symver sendmmsg,sendmmsg@GLIBC_2.14"); +__asm__(".symver sendmsg,sendmsg@GLIBC_2.2.5"); +__asm__(".symver sendto,sendto@GLIBC_2.2.5"); +__asm__(".symver setaliasent,setaliasent@GLIBC_2.2.5"); +__asm__(".symver setbuf,setbuf@GLIBC_2.2.5"); +__asm__(".symver setbuffer,setbuffer@GLIBC_2.2.5"); +__asm__(".symver setcontext,setcontext@GLIBC_2.2.5"); +__asm__(".symver setdomainname,setdomainname@GLIBC_2.2.5"); +__asm__(".symver setegid,setegid@GLIBC_2.2.5"); +__asm__(".symver setenv,setenv@GLIBC_2.2.5"); +__asm__(".symver seteuid,seteuid@GLIBC_2.2.5"); +__asm__(".symver setfsent,setfsent@GLIBC_2.2.5"); +__asm__(".symver setfsgid,setfsgid@GLIBC_2.2.5"); +__asm__(".symver setfsuid,setfsuid@GLIBC_2.2.5"); +__asm__(".symver setgid,setgid@GLIBC_2.2.5"); +__asm__(".symver setgrent,setgrent@GLIBC_2.2.5"); +__asm__(".symver setgroups,setgroups@GLIBC_2.2.5"); +__asm__(".symver sethostent,sethostent@GLIBC_2.2.5"); +__asm__(".symver sethostid,sethostid@GLIBC_2.2.5"); +__asm__(".symver sethostname,sethostname@GLIBC_2.2.5"); +__asm__(".symver setipv4sourcefilter,setipv4sourcefilter@GLIBC_2.3.4"); +__asm__(".symver setitimer,setitimer@GLIBC_2.2.5"); +__asm__(".symver setjmp,setjmp@GLIBC_2.2.5"); +__asm__(".symver setkey,setkey@GLIBC_2.2.5"); +__asm__(".symver setkey_r,setkey_r@GLIBC_2.2.5"); +__asm__(".symver setlinebuf,setlinebuf@GLIBC_2.2.5"); +__asm__(".symver setlocale,setlocale@GLIBC_2.2.5"); +__asm__(".symver setlogin,setlogin@GLIBC_2.2.5"); +__asm__(".symver setlogmask,setlogmask@GLIBC_2.2.5"); +__asm__(".symver setmntent,setmntent@GLIBC_2.2.5"); +__asm__(".symver setnetent,setnetent@GLIBC_2.2.5"); +__asm__(".symver setnetgrent,setnetgrent@GLIBC_2.2.5"); +__asm__(".symver setns,setns@GLIBC_2.14"); +__asm__(".symver setpgid,setpgid@GLIBC_2.2.5"); +__asm__(".symver setpgrp,setpgrp@GLIBC_2.2.5"); +__asm__(".symver setpriority,setpriority@GLIBC_2.2.5"); +__asm__(".symver setprotoent,setprotoent@GLIBC_2.2.5"); +__asm__(".symver setpwent,setpwent@GLIBC_2.2.5"); +__asm__(".symver setregid,setregid@GLIBC_2.2.5"); +__asm__(".symver setresgid,setresgid@GLIBC_2.2.5"); +__asm__(".symver setresuid,setresuid@GLIBC_2.2.5"); +__asm__(".symver setreuid,setreuid@GLIBC_2.2.5"); +__asm__(".symver setrlimit,setrlimit@GLIBC_2.2.5"); +__asm__(".symver setrlimit64,setrlimit64@GLIBC_2.2.5"); +__asm__(".symver setrpcent,setrpcent@GLIBC_2.2.5"); +__asm__(".symver setservent,setservent@GLIBC_2.2.5"); +__asm__(".symver setsgent,setsgent@GLIBC_2.10"); +__asm__(".symver setsid,setsid@GLIBC_2.2.5"); +__asm__(".symver setsockopt,setsockopt@GLIBC_2.2.5"); +__asm__(".symver setsourcefilter,setsourcefilter@GLIBC_2.3.4"); +__asm__(".symver setspent,setspent@GLIBC_2.2.5"); +__asm__(".symver setstate,setstate@GLIBC_2.2.5"); +__asm__(".symver setstate_r,setstate_r@GLIBC_2.2.5"); +__asm__(".symver settimeofday,settimeofday@GLIBC_2.2.5"); +__asm__(".symver setttyent,setttyent@GLIBC_2.2.5"); +__asm__(".symver setuid,setuid@GLIBC_2.2.5"); +__asm__(".symver setusershell,setusershell@GLIBC_2.2.5"); +__asm__(".symver setutent,setutent@GLIBC_2.2.5"); +__asm__(".symver setutxent,setutxent@GLIBC_2.2.5"); +__asm__(".symver setvbuf,setvbuf@GLIBC_2.2.5"); +__asm__(".symver setxattr,setxattr@GLIBC_2.3"); +__asm__(".symver sgetsgent,sgetsgent@GLIBC_2.10"); +__asm__(".symver sgetsgent_r,sgetsgent_r@GLIBC_2.10"); +__asm__(".symver sgetspent,sgetspent@GLIBC_2.2.5"); +__asm__(".symver sgetspent_r,sgetspent_r@GLIBC_2.2.5"); +__asm__(".symver shm_open,shm_open@GLIBC_2.2.5"); +__asm__(".symver shm_unlink,shm_unlink@GLIBC_2.2.5"); +__asm__(".symver shmat,shmat@GLIBC_2.2.5"); +__asm__(".symver shmctl,shmctl@GLIBC_2.2.5"); +__asm__(".symver shmdt,shmdt@GLIBC_2.2.5"); +__asm__(".symver shmget,shmget@GLIBC_2.2.5"); +__asm__(".symver shutdown,shutdown@GLIBC_2.2.5"); +__asm__(".symver sigaction,sigaction@GLIBC_2.2.5"); +__asm__(".symver sigaddset,sigaddset@GLIBC_2.2.5"); +__asm__(".symver sigaltstack,sigaltstack@GLIBC_2.2.5"); +__asm__(".symver sigandset,sigandset@GLIBC_2.2.5"); +__asm__(".symver sigblock,sigblock@GLIBC_2.2.5"); +__asm__(".symver sigdelset,sigdelset@GLIBC_2.2.5"); +__asm__(".symver sigemptyset,sigemptyset@GLIBC_2.2.5"); +__asm__(".symver sigfillset,sigfillset@GLIBC_2.2.5"); +__asm__(".symver siggetmask,siggetmask@GLIBC_2.2.5"); +__asm__(".symver sighold,sighold@GLIBC_2.2.5"); +__asm__(".symver sigignore,sigignore@GLIBC_2.2.5"); +__asm__(".symver siginterrupt,siginterrupt@GLIBC_2.2.5"); +__asm__(".symver sigisemptyset,sigisemptyset@GLIBC_2.2.5"); +__asm__(".symver sigismember,sigismember@GLIBC_2.2.5"); +__asm__(".symver siglongjmp,siglongjmp@GLIBC_2.2.5"); +__asm__(".symver signal,signal@GLIBC_2.2.5"); +__asm__(".symver signalfd,signalfd@GLIBC_2.7"); +__asm__(".symver signgam,signgam@GLIBC_2.2.5"); +__asm__(".symver significand,significand@GLIBC_2.2.5"); +__asm__(".symver significandf,significandf@GLIBC_2.2.5"); +__asm__(".symver significandl,significandl@GLIBC_2.2.5"); +__asm__(".symver sigorset,sigorset@GLIBC_2.2.5"); +__asm__(".symver sigpause,sigpause@GLIBC_2.2.5"); +__asm__(".symver sigpending,sigpending@GLIBC_2.2.5"); +__asm__(".symver sigprocmask,sigprocmask@GLIBC_2.2.5"); +__asm__(".symver sigqueue,sigqueue@GLIBC_2.2.5"); +__asm__(".symver sigrelse,sigrelse@GLIBC_2.2.5"); +__asm__(".symver sigreturn,sigreturn@GLIBC_2.2.5"); +__asm__(".symver sigset,sigset@GLIBC_2.2.5"); +__asm__(".symver sigsetmask,sigsetmask@GLIBC_2.2.5"); +__asm__(".symver sigstack,sigstack@GLIBC_2.2.5"); +__asm__(".symver sigsuspend,sigsuspend@GLIBC_2.2.5"); +__asm__(".symver sigtimedwait,sigtimedwait@GLIBC_2.2.5"); +__asm__(".symver sigwait,sigwait@GLIBC_2.2.5"); +__asm__(".symver sigwaitinfo,sigwaitinfo@GLIBC_2.2.5"); +__asm__(".symver sin,sin@GLIBC_2.2.5"); +__asm__(".symver sincos,sincos@GLIBC_2.2.5"); +__asm__(".symver sincosf,sincosf@GLIBC_2.2.5"); +__asm__(".symver sincosl,sincosl@GLIBC_2.2.5"); +__asm__(".symver sinf,sinf@GLIBC_2.2.5"); +__asm__(".symver sinh,sinh@GLIBC_2.2.5"); +__asm__(".symver sinhf,sinhf@GLIBC_2.2.5"); +__asm__(".symver sinhl,sinhl@GLIBC_2.2.5"); +__asm__(".symver sinl,sinl@GLIBC_2.2.5"); +__asm__(".symver sleep,sleep@GLIBC_2.2.5"); +__asm__(".symver snprintf,snprintf@GLIBC_2.2.5"); +__asm__(".symver sockatmark,sockatmark@GLIBC_2.2.5"); +__asm__(".symver socket,socket@GLIBC_2.2.5"); +__asm__(".symver socketpair,socketpair@GLIBC_2.2.5"); +__asm__(".symver splice,splice@GLIBC_2.5"); +__asm__(".symver sprintf,sprintf@GLIBC_2.2.5"); +__asm__(".symver sprofil,sprofil@GLIBC_2.2.5"); +__asm__(".symver sqrt,sqrt@GLIBC_2.2.5"); +__asm__(".symver sqrtf,sqrtf@GLIBC_2.2.5"); +__asm__(".symver sqrtl,sqrtl@GLIBC_2.2.5"); +__asm__(".symver srand,srand@GLIBC_2.2.5"); +__asm__(".symver srand48,srand48@GLIBC_2.2.5"); +__asm__(".symver srand48_r,srand48_r@GLIBC_2.2.5"); +__asm__(".symver srandom,srandom@GLIBC_2.2.5"); +__asm__(".symver srandom_r,srandom_r@GLIBC_2.2.5"); +__asm__(".symver sscanf,sscanf@GLIBC_2.2.5"); +__asm__(".symver ssignal,ssignal@GLIBC_2.2.5"); +__asm__(".symver sstk,sstk@GLIBC_2.2.5"); +__asm__(".symver statfs,statfs@GLIBC_2.2.5"); +__asm__(".symver statfs64,statfs64@GLIBC_2.2.5"); +__asm__(".symver statvfs,statvfs@GLIBC_2.2.5"); +__asm__(".symver statvfs64,statvfs64@GLIBC_2.2.5"); +__asm__(".symver stderr,stderr@GLIBC_2.2.5"); +__asm__(".symver stdin,stdin@GLIBC_2.2.5"); +__asm__(".symver stdout,stdout@GLIBC_2.2.5"); +__asm__(".symver stime,stime@GLIBC_2.2.5"); +__asm__(".symver stpcpy,stpcpy@GLIBC_2.2.5"); +__asm__(".symver stpncpy,stpncpy@GLIBC_2.2.5"); +__asm__(".symver strcasecmp,strcasecmp@GLIBC_2.2.5"); +__asm__(".symver strcasecmp_l,strcasecmp_l@GLIBC_2.3"); +__asm__(".symver strcasestr,strcasestr@GLIBC_2.2.5"); +__asm__(".symver strcat,strcat@GLIBC_2.2.5"); +__asm__(".symver strchr,strchr@GLIBC_2.2.5"); +__asm__(".symver strchrnul,strchrnul@GLIBC_2.2.5"); +__asm__(".symver strcmp,strcmp@GLIBC_2.2.5"); +__asm__(".symver strcoll,strcoll@GLIBC_2.2.5"); +__asm__(".symver strcoll_l,strcoll_l@GLIBC_2.3"); +__asm__(".symver strcpy,strcpy@GLIBC_2.2.5"); +__asm__(".symver strcspn,strcspn@GLIBC_2.2.5"); +__asm__(".symver strdup,strdup@GLIBC_2.2.5"); +__asm__(".symver strerror,strerror@GLIBC_2.2.5"); +__asm__(".symver strerror_l,strerror_l@GLIBC_2.6"); +__asm__(".symver strerror_r,strerror_r@GLIBC_2.2.5"); +__asm__(".symver strfmon,strfmon@GLIBC_2.2.5"); +__asm__(".symver strfmon_l,strfmon_l@GLIBC_2.3"); +__asm__(".symver strfry,strfry@GLIBC_2.2.5"); +__asm__(".symver strftime,strftime@GLIBC_2.2.5"); +__asm__(".symver strftime_l,strftime_l@GLIBC_2.3"); +__asm__(".symver strlen,strlen@GLIBC_2.2.5"); +__asm__(".symver strncasecmp,strncasecmp@GLIBC_2.2.5"); +__asm__(".symver strncasecmp_l,strncasecmp_l@GLIBC_2.3"); +__asm__(".symver strncat,strncat@GLIBC_2.2.5"); +__asm__(".symver strncmp,strncmp@GLIBC_2.2.5"); +__asm__(".symver strncpy,strncpy@GLIBC_2.2.5"); +__asm__(".symver strndup,strndup@GLIBC_2.2.5"); +__asm__(".symver strnlen,strnlen@GLIBC_2.2.5"); +__asm__(".symver strpbrk,strpbrk@GLIBC_2.2.5"); +__asm__(".symver strptime,strptime@GLIBC_2.2.5"); +__asm__(".symver strptime_l,strptime_l@GLIBC_2.3.2"); +__asm__(".symver strrchr,strrchr@GLIBC_2.2.5"); +__asm__(".symver strsep,strsep@GLIBC_2.2.5"); +__asm__(".symver strsignal,strsignal@GLIBC_2.2.5"); +__asm__(".symver strspn,strspn@GLIBC_2.2.5"); +__asm__(".symver strstr,strstr@GLIBC_2.2.5"); +__asm__(".symver strtod,strtod@GLIBC_2.2.5"); +__asm__(".symver strtod_l,strtod_l@GLIBC_2.3"); +__asm__(".symver strtof,strtof@GLIBC_2.2.5"); +__asm__(".symver strtof_l,strtof_l@GLIBC_2.3"); +__asm__(".symver strtoimax,strtoimax@GLIBC_2.2.5"); +__asm__(".symver strtok,strtok@GLIBC_2.2.5"); +__asm__(".symver strtok_r,strtok_r@GLIBC_2.2.5"); +__asm__(".symver strtol,strtol@GLIBC_2.2.5"); +__asm__(".symver strtol_l,strtol_l@GLIBC_2.3"); +__asm__(".symver strtold,strtold@GLIBC_2.2.5"); +__asm__(".symver strtold_l,strtold_l@GLIBC_2.3"); +__asm__(".symver strtoll,strtoll@GLIBC_2.2.5"); +__asm__(".symver strtoll_l,strtoll_l@GLIBC_2.3.3"); +__asm__(".symver strtoq,strtoq@GLIBC_2.2.5"); +__asm__(".symver strtoul,strtoul@GLIBC_2.2.5"); +__asm__(".symver strtoul_l,strtoul_l@GLIBC_2.3"); +__asm__(".symver strtoull,strtoull@GLIBC_2.2.5"); +__asm__(".symver strtoull_l,strtoull_l@GLIBC_2.3.3"); +__asm__(".symver strtoumax,strtoumax@GLIBC_2.2.5"); +__asm__(".symver strtouq,strtouq@GLIBC_2.2.5"); +__asm__(".symver strverscmp,strverscmp@GLIBC_2.2.5"); +__asm__(".symver strxfrm,strxfrm@GLIBC_2.2.5"); +__asm__(".symver strxfrm_l,strxfrm_l@GLIBC_2.3"); +__asm__(".symver stty,stty@GLIBC_2.2.5"); +__asm__(".symver svc_fdset,svc_fdset@GLIBC_2.2.5"); +__asm__(".symver svc_getreq_poll,svc_getreq_poll@GLIBC_2.2.5"); +__asm__(".symver svc_max_pollfd,svc_max_pollfd@GLIBC_2.2.5"); +__asm__(".symver svc_pollfd,svc_pollfd@GLIBC_2.2.5"); +__asm__(".symver svc_register,svc_register@GLIBC_2.2.5"); +__asm__(".symver svc_sendreply,svc_sendreply@GLIBC_2.2.5"); +__asm__(".symver svcauthdes_stats,svcauthdes_stats@GLIBC_2.2.5"); +__asm__(".symver svcerr_decode,svcerr_decode@GLIBC_2.2.5"); +__asm__(".symver svcerr_noproc,svcerr_noproc@GLIBC_2.2.5"); +__asm__(".symver svcerr_systemerr,svcerr_systemerr@GLIBC_2.2.5"); +__asm__(".symver svctcp_create,svctcp_create@GLIBC_2.2.5"); +__asm__(".symver svcudp_bufcreate,svcudp_bufcreate@GLIBC_2.2.5"); +__asm__(".symver swab,swab@GLIBC_2.2.5"); +__asm__(".symver swapcontext,swapcontext@GLIBC_2.2.5"); +__asm__(".symver swapoff,swapoff@GLIBC_2.2.5"); +__asm__(".symver swapon,swapon@GLIBC_2.2.5"); +__asm__(".symver swprintf,swprintf@GLIBC_2.2.5"); +__asm__(".symver swscanf,swscanf@GLIBC_2.2.5"); +__asm__(".symver symlink,symlink@GLIBC_2.2.5"); +__asm__(".symver symlinkat,symlinkat@GLIBC_2.4"); +__asm__(".symver sync,sync@GLIBC_2.2.5"); +__asm__(".symver sync_file_range,sync_file_range@GLIBC_2.6"); +__asm__(".symver syncfs,syncfs@GLIBC_2.14"); +__asm__(".symver sys_errlist,sys_errlist@GLIBC_2.12"); +__asm__(".symver sys_nerr,sys_nerr@GLIBC_2.12"); +__asm__(".symver sys_sigabbrev,sys_sigabbrev@GLIBC_2.3.3"); +__asm__(".symver sys_siglist,sys_siglist@GLIBC_2.3.3"); +__asm__(".symver syscall,syscall@GLIBC_2.2.5"); +__asm__(".symver sysconf,sysconf@GLIBC_2.2.5"); +__asm__(".symver sysctl,sysctl@GLIBC_2.2.5"); +__asm__(".symver sysinfo,sysinfo@GLIBC_2.2.5"); +__asm__(".symver syslog,syslog@GLIBC_2.2.5"); +__asm__(".symver system,system@GLIBC_2.2.5"); +__asm__(".symver sysv_signal,sysv_signal@GLIBC_2.2.5"); +__asm__(".symver tan,tan@GLIBC_2.2.5"); +__asm__(".symver tanf,tanf@GLIBC_2.2.5"); +__asm__(".symver tanh,tanh@GLIBC_2.2.5"); +__asm__(".symver tanhf,tanhf@GLIBC_2.2.5"); +__asm__(".symver tanhl,tanhl@GLIBC_2.2.5"); +__asm__(".symver tanl,tanl@GLIBC_2.2.5"); +__asm__(".symver tcdrain,tcdrain@GLIBC_2.2.5"); +__asm__(".symver tcflow,tcflow@GLIBC_2.2.5"); +__asm__(".symver tcflush,tcflush@GLIBC_2.2.5"); +__asm__(".symver tcgetattr,tcgetattr@GLIBC_2.2.5"); +__asm__(".symver tcgetpgrp,tcgetpgrp@GLIBC_2.2.5"); +__asm__(".symver tcgetsid,tcgetsid@GLIBC_2.2.5"); +__asm__(".symver tcsendbreak,tcsendbreak@GLIBC_2.2.5"); +__asm__(".symver tcsetattr,tcsetattr@GLIBC_2.2.5"); +__asm__(".symver tcsetpgrp,tcsetpgrp@GLIBC_2.2.5"); +__asm__(".symver td_init,td_init@GLIBC_2.2.5"); +__asm__(".symver td_log,td_log@GLIBC_2.2.5"); +__asm__(".symver td_symbol_list,td_symbol_list@GLIBC_2.2.5"); +__asm__(".symver td_ta_clear_event,td_ta_clear_event@GLIBC_2.2.5"); +__asm__(".symver td_ta_delete,td_ta_delete@GLIBC_2.2.5"); +__asm__(".symver td_ta_enable_stats,td_ta_enable_stats@GLIBC_2.2.5"); +__asm__(".symver td_ta_event_addr,td_ta_event_addr@GLIBC_2.2.5"); +__asm__(".symver td_ta_event_getmsg,td_ta_event_getmsg@GLIBC_2.2.5"); +__asm__(".symver td_ta_get_nthreads,td_ta_get_nthreads@GLIBC_2.2.5"); +__asm__(".symver td_ta_get_ph,td_ta_get_ph@GLIBC_2.2.5"); +__asm__(".symver td_ta_get_stats,td_ta_get_stats@GLIBC_2.2.5"); +__asm__(".symver td_ta_map_id2thr,td_ta_map_id2thr@GLIBC_2.2.5"); +__asm__(".symver td_ta_map_lwp2thr,td_ta_map_lwp2thr@GLIBC_2.2.5"); +__asm__(".symver td_ta_new,td_ta_new@GLIBC_2.2.5"); +__asm__(".symver td_ta_reset_stats,td_ta_reset_stats@GLIBC_2.2.5"); +__asm__(".symver td_ta_set_event,td_ta_set_event@GLIBC_2.2.5"); +__asm__(".symver td_ta_setconcurrency,td_ta_setconcurrency@GLIBC_2.2.5"); +__asm__(".symver td_ta_thr_iter,td_ta_thr_iter@GLIBC_2.2.5"); +__asm__(".symver td_ta_tsd_iter,td_ta_tsd_iter@GLIBC_2.2.5"); +__asm__(".symver td_thr_clear_event,td_thr_clear_event@GLIBC_2.2.5"); +__asm__(".symver td_thr_dbresume,td_thr_dbresume@GLIBC_2.2.5"); +__asm__(".symver td_thr_dbsuspend,td_thr_dbsuspend@GLIBC_2.2.5"); +__asm__(".symver td_thr_event_enable,td_thr_event_enable@GLIBC_2.2.5"); +__asm__(".symver td_thr_event_getmsg,td_thr_event_getmsg@GLIBC_2.2.5"); +__asm__(".symver td_thr_get_info,td_thr_get_info@GLIBC_2.2.5"); +__asm__(".symver td_thr_getfpregs,td_thr_getfpregs@GLIBC_2.2.5"); +__asm__(".symver td_thr_getgregs,td_thr_getgregs@GLIBC_2.2.5"); +__asm__(".symver td_thr_getxregs,td_thr_getxregs@GLIBC_2.2.5"); +__asm__(".symver td_thr_getxregsize,td_thr_getxregsize@GLIBC_2.2.5"); +__asm__(".symver td_thr_set_event,td_thr_set_event@GLIBC_2.2.5"); +__asm__(".symver td_thr_setfpregs,td_thr_setfpregs@GLIBC_2.2.5"); +__asm__(".symver td_thr_setgregs,td_thr_setgregs@GLIBC_2.2.5"); +__asm__(".symver td_thr_setprio,td_thr_setprio@GLIBC_2.2.5"); +__asm__(".symver td_thr_setsigpending,td_thr_setsigpending@GLIBC_2.2.5"); +__asm__(".symver td_thr_setxregs,td_thr_setxregs@GLIBC_2.2.5"); +__asm__(".symver td_thr_sigsetmask,td_thr_sigsetmask@GLIBC_2.2.5"); +__asm__(".symver td_thr_tls_get_addr,td_thr_tls_get_addr@GLIBC_2.3"); +__asm__(".symver td_thr_tlsbase,td_thr_tlsbase@GLIBC_2.3.3"); +__asm__(".symver td_thr_tsd,td_thr_tsd@GLIBC_2.2.5"); +__asm__(".symver td_thr_validate,td_thr_validate@GLIBC_2.2.5"); +__asm__(".symver tdelete,tdelete@GLIBC_2.2.5"); +__asm__(".symver tdestroy,tdestroy@GLIBC_2.2.5"); +__asm__(".symver tee,tee@GLIBC_2.5"); +__asm__(".symver telldir,telldir@GLIBC_2.2.5"); +__asm__(".symver tempnam,tempnam@GLIBC_2.2.5"); +__asm__(".symver textdomain,textdomain@GLIBC_2.2.5"); +__asm__(".symver tfind,tfind@GLIBC_2.2.5"); +__asm__(".symver tgamma,tgamma@GLIBC_2.2.5"); +__asm__(".symver tgammaf,tgammaf@GLIBC_2.2.5"); +__asm__(".symver tgammal,tgammal@GLIBC_2.2.5"); +__asm__(".symver time,time@GLIBC_2.2.5"); +__asm__(".symver timegm,timegm@GLIBC_2.2.5"); +__asm__(".symver timelocal,timelocal@GLIBC_2.2.5"); +__asm__(".symver timer_create,timer_create@GLIBC_2.3.3"); +__asm__(".symver timer_delete,timer_delete@GLIBC_2.3.3"); +__asm__(".symver timer_getoverrun,timer_getoverrun@GLIBC_2.3.3"); +__asm__(".symver timer_gettime,timer_gettime@GLIBC_2.3.3"); +__asm__(".symver timer_settime,timer_settime@GLIBC_2.3.3"); +__asm__(".symver timerfd_create,timerfd_create@GLIBC_2.8"); +__asm__(".symver timerfd_gettime,timerfd_gettime@GLIBC_2.8"); +__asm__(".symver timerfd_settime,timerfd_settime@GLIBC_2.8"); +__asm__(".symver times,times@GLIBC_2.2.5"); +__asm__(".symver timespec_get,timespec_get@GLIBC_2.16"); +__asm__(".symver timezone,timezone@GLIBC_2.2.5"); +__asm__(".symver tmpfile,tmpfile@GLIBC_2.2.5"); +__asm__(".symver tmpfile64,tmpfile64@GLIBC_2.2.5"); +__asm__(".symver tmpnam,tmpnam@GLIBC_2.2.5"); +__asm__(".symver tmpnam_r,tmpnam_r@GLIBC_2.2.5"); +__asm__(".symver toascii,toascii@GLIBC_2.2.5"); +__asm__(".symver tolower,tolower@GLIBC_2.2.5"); +__asm__(".symver tolower_l,tolower_l@GLIBC_2.3"); +__asm__(".symver toupper,toupper@GLIBC_2.2.5"); +__asm__(".symver toupper_l,toupper_l@GLIBC_2.3"); +__asm__(".symver towctrans,towctrans@GLIBC_2.2.5"); +__asm__(".symver towctrans_l,towctrans_l@GLIBC_2.3"); +__asm__(".symver towlower,towlower@GLIBC_2.2.5"); +__asm__(".symver towlower_l,towlower_l@GLIBC_2.3"); +__asm__(".symver towupper,towupper@GLIBC_2.2.5"); +__asm__(".symver towupper_l,towupper_l@GLIBC_2.3"); +__asm__(".symver tr_break,tr_break@GLIBC_2.2.5"); +__asm__(".symver trunc,trunc@GLIBC_2.2.5"); +__asm__(".symver truncate,truncate@GLIBC_2.2.5"); +__asm__(".symver truncate64,truncate64@GLIBC_2.2.5"); +__asm__(".symver truncf,truncf@GLIBC_2.2.5"); +__asm__(".symver truncl,truncl@GLIBC_2.2.5"); +__asm__(".symver tsearch,tsearch@GLIBC_2.2.5"); +__asm__(".symver ttyname,ttyname@GLIBC_2.2.5"); +__asm__(".symver ttyname_r,ttyname_r@GLIBC_2.2.5"); +__asm__(".symver ttyslot,ttyslot@GLIBC_2.2.5"); +__asm__(".symver twalk,twalk@GLIBC_2.2.5"); +__asm__(".symver tzname,tzname@GLIBC_2.2.5"); +__asm__(".symver tzset,tzset@GLIBC_2.2.5"); +__asm__(".symver ualarm,ualarm@GLIBC_2.2.5"); +__asm__(".symver ulckpwdf,ulckpwdf@GLIBC_2.2.5"); +__asm__(".symver ulimit,ulimit@GLIBC_2.2.5"); +__asm__(".symver umask,umask@GLIBC_2.2.5"); +__asm__(".symver umount,umount@GLIBC_2.2.5"); +__asm__(".symver umount2,umount2@GLIBC_2.2.5"); +__asm__(".symver uname,uname@GLIBC_2.2.5"); +__asm__(".symver ungetc,ungetc@GLIBC_2.2.5"); +__asm__(".symver ungetwc,ungetwc@GLIBC_2.2.5"); +__asm__(".symver unlink,unlink@GLIBC_2.2.5"); +__asm__(".symver unlinkat,unlinkat@GLIBC_2.4"); +__asm__(".symver unlockpt,unlockpt@GLIBC_2.2.5"); +__asm__(".symver unsetenv,unsetenv@GLIBC_2.2.5"); +__asm__(".symver unshare,unshare@GLIBC_2.4"); +__asm__(".symver updwtmp,updwtmp@GLIBC_2.2.5"); +__asm__(".symver updwtmpx,updwtmpx@GLIBC_2.2.5"); +__asm__(".symver uselocale,uselocale@GLIBC_2.3"); +__asm__(".symver usleep,usleep@GLIBC_2.2.5"); +__asm__(".symver ustat,ustat@GLIBC_2.2.5"); +__asm__(".symver utime,utime@GLIBC_2.2.5"); +__asm__(".symver utimensat,utimensat@GLIBC_2.6"); +__asm__(".symver utimes,utimes@GLIBC_2.2.5"); +__asm__(".symver utmpname,utmpname@GLIBC_2.2.5"); +__asm__(".symver utmpxname,utmpxname@GLIBC_2.2.5"); +__asm__(".symver valloc,valloc@GLIBC_2.2.5"); +__asm__(".symver vasprintf,vasprintf@GLIBC_2.2.5"); +__asm__(".symver vdprintf,vdprintf@GLIBC_2.2.5"); +__asm__(".symver verr,verr@GLIBC_2.2.5"); +__asm__(".symver verrx,verrx@GLIBC_2.2.5"); +__asm__(".symver versionsort,versionsort@GLIBC_2.2.5"); +__asm__(".symver versionsort64,versionsort64@GLIBC_2.2.5"); +__asm__(".symver vfork,vfork@GLIBC_2.2.5"); +__asm__(".symver vfprintf,vfprintf@GLIBC_2.2.5"); +__asm__(".symver vfscanf,vfscanf@GLIBC_2.2.5"); +__asm__(".symver vfwprintf,vfwprintf@GLIBC_2.2.5"); +__asm__(".symver vfwscanf,vfwscanf@GLIBC_2.2.5"); +__asm__(".symver vhangup,vhangup@GLIBC_2.2.5"); +__asm__(".symver vlimit,vlimit@GLIBC_2.2.5"); +__asm__(".symver vmsplice,vmsplice@GLIBC_2.5"); +__asm__(".symver vprintf,vprintf@GLIBC_2.2.5"); +__asm__(".symver vscanf,vscanf@GLIBC_2.2.5"); +__asm__(".symver vsnprintf,vsnprintf@GLIBC_2.2.5"); +__asm__(".symver vsprintf,vsprintf@GLIBC_2.2.5"); +__asm__(".symver vsscanf,vsscanf@GLIBC_2.2.5"); +__asm__(".symver vswprintf,vswprintf@GLIBC_2.2.5"); +__asm__(".symver vswscanf,vswscanf@GLIBC_2.2.5"); +__asm__(".symver vsyslog,vsyslog@GLIBC_2.2.5"); +__asm__(".symver vtimes,vtimes@GLIBC_2.2.5"); +__asm__(".symver vwarn,vwarn@GLIBC_2.2.5"); +__asm__(".symver vwarnx,vwarnx@GLIBC_2.2.5"); +__asm__(".symver vwprintf,vwprintf@GLIBC_2.2.5"); +__asm__(".symver vwscanf,vwscanf@GLIBC_2.2.5"); +__asm__(".symver wait,wait@GLIBC_2.2.5"); +__asm__(".symver wait3,wait3@GLIBC_2.2.5"); +__asm__(".symver wait4,wait4@GLIBC_2.2.5"); +__asm__(".symver waitid,waitid@GLIBC_2.2.5"); +__asm__(".symver waitpid,waitpid@GLIBC_2.2.5"); +__asm__(".symver warn,warn@GLIBC_2.2.5"); +__asm__(".symver warnx,warnx@GLIBC_2.2.5"); +__asm__(".symver wcpcpy,wcpcpy@GLIBC_2.2.5"); +__asm__(".symver wcpncpy,wcpncpy@GLIBC_2.2.5"); +__asm__(".symver wcrtomb,wcrtomb@GLIBC_2.2.5"); +__asm__(".symver wcscasecmp,wcscasecmp@GLIBC_2.2.5"); +__asm__(".symver wcscasecmp_l,wcscasecmp_l@GLIBC_2.3"); +__asm__(".symver wcscat,wcscat@GLIBC_2.2.5"); +__asm__(".symver wcschr,wcschr@GLIBC_2.2.5"); +__asm__(".symver wcschrnul,wcschrnul@GLIBC_2.2.5"); +__asm__(".symver wcscmp,wcscmp@GLIBC_2.2.5"); +__asm__(".symver wcscoll,wcscoll@GLIBC_2.2.5"); +__asm__(".symver wcscoll_l,wcscoll_l@GLIBC_2.3"); +__asm__(".symver wcscpy,wcscpy@GLIBC_2.2.5"); +__asm__(".symver wcscspn,wcscspn@GLIBC_2.2.5"); +__asm__(".symver wcsdup,wcsdup@GLIBC_2.2.5"); +__asm__(".symver wcsftime,wcsftime@GLIBC_2.2.5"); +__asm__(".symver wcsftime_l,wcsftime_l@GLIBC_2.3"); +__asm__(".symver wcslen,wcslen@GLIBC_2.2.5"); +__asm__(".symver wcsncasecmp,wcsncasecmp@GLIBC_2.2.5"); +__asm__(".symver wcsncasecmp_l,wcsncasecmp_l@GLIBC_2.3"); +__asm__(".symver wcsncat,wcsncat@GLIBC_2.2.5"); +__asm__(".symver wcsncmp,wcsncmp@GLIBC_2.2.5"); +__asm__(".symver wcsncpy,wcsncpy@GLIBC_2.2.5"); +__asm__(".symver wcsnlen,wcsnlen@GLIBC_2.2.5"); +__asm__(".symver wcsnrtombs,wcsnrtombs@GLIBC_2.2.5"); +__asm__(".symver wcspbrk,wcspbrk@GLIBC_2.2.5"); +__asm__(".symver wcsrchr,wcsrchr@GLIBC_2.2.5"); +__asm__(".symver wcsrtombs,wcsrtombs@GLIBC_2.2.5"); +__asm__(".symver wcsspn,wcsspn@GLIBC_2.2.5"); +__asm__(".symver wcsstr,wcsstr@GLIBC_2.2.5"); +__asm__(".symver wcstod,wcstod@GLIBC_2.2.5"); +__asm__(".symver wcstod_l,wcstod_l@GLIBC_2.3"); +__asm__(".symver wcstof,wcstof@GLIBC_2.2.5"); +__asm__(".symver wcstof_l,wcstof_l@GLIBC_2.3"); +__asm__(".symver wcstoimax,wcstoimax@GLIBC_2.2.5"); +__asm__(".symver wcstok,wcstok@GLIBC_2.2.5"); +__asm__(".symver wcstol,wcstol@GLIBC_2.2.5"); +__asm__(".symver wcstol_l,wcstol_l@GLIBC_2.3"); +__asm__(".symver wcstold,wcstold@GLIBC_2.2.5"); +__asm__(".symver wcstold_l,wcstold_l@GLIBC_2.3"); +__asm__(".symver wcstoll,wcstoll@GLIBC_2.2.5"); +__asm__(".symver wcstoll_l,wcstoll_l@GLIBC_2.3"); +__asm__(".symver wcstombs,wcstombs@GLIBC_2.2.5"); +__asm__(".symver wcstoq,wcstoq@GLIBC_2.2.5"); +__asm__(".symver wcstoul,wcstoul@GLIBC_2.2.5"); +__asm__(".symver wcstoul_l,wcstoul_l@GLIBC_2.3"); +__asm__(".symver wcstoull,wcstoull@GLIBC_2.2.5"); +__asm__(".symver wcstoull_l,wcstoull_l@GLIBC_2.3"); +__asm__(".symver wcstoumax,wcstoumax@GLIBC_2.2.5"); +__asm__(".symver wcstouq,wcstouq@GLIBC_2.2.5"); +__asm__(".symver wcswcs,wcswcs@GLIBC_2.2.5"); +__asm__(".symver wcswidth,wcswidth@GLIBC_2.2.5"); +__asm__(".symver wcsxfrm,wcsxfrm@GLIBC_2.2.5"); +__asm__(".symver wcsxfrm_l,wcsxfrm_l@GLIBC_2.3"); +__asm__(".symver wctob,wctob@GLIBC_2.2.5"); +__asm__(".symver wctomb,wctomb@GLIBC_2.2.5"); +__asm__(".symver wctrans,wctrans@GLIBC_2.2.5"); +__asm__(".symver wctrans_l,wctrans_l@GLIBC_2.3"); +__asm__(".symver wctype,wctype@GLIBC_2.2.5"); +__asm__(".symver wctype_l,wctype_l@GLIBC_2.3"); +__asm__(".symver wcwidth,wcwidth@GLIBC_2.2.5"); +__asm__(".symver wmemchr,wmemchr@GLIBC_2.2.5"); +__asm__(".symver wmemcmp,wmemcmp@GLIBC_2.2.5"); +__asm__(".symver wmemcpy,wmemcpy@GLIBC_2.2.5"); +__asm__(".symver wmemmove,wmemmove@GLIBC_2.2.5"); +__asm__(".symver wmempcpy,wmempcpy@GLIBC_2.2.5"); +__asm__(".symver wmemset,wmemset@GLIBC_2.2.5"); +__asm__(".symver wordexp,wordexp@GLIBC_2.2.5"); +__asm__(".symver wordfree,wordfree@GLIBC_2.2.5"); +__asm__(".symver wprintf,wprintf@GLIBC_2.2.5"); +__asm__(".symver write,write@GLIBC_2.2.5"); +__asm__(".symver writeColdStartFile,writeColdStartFile@GLIBC_2.2.5"); +__asm__(".symver writev,writev@GLIBC_2.2.5"); +__asm__(".symver wscanf,wscanf@GLIBC_2.2.5"); +__asm__(".symver xdecrypt,xdecrypt@GLIBC_2.2.5"); +__asm__(".symver xdr_array,xdr_array@GLIBC_2.2.5"); +__asm__(".symver xdr_bool,xdr_bool@GLIBC_2.2.5"); +__asm__(".symver xdr_bytes,xdr_bytes@GLIBC_2.2.5"); +__asm__(".symver xdr_cback_data,xdr_cback_data@GLIBC_2.2.5"); +__asm__(".symver xdr_domainname,xdr_domainname@GLIBC_2.2.5"); +__asm__(".symver xdr_enum,xdr_enum@GLIBC_2.2.5"); +__asm__(".symver xdr_free,xdr_free@GLIBC_2.2.5"); +__asm__(".symver xdr_int,xdr_int@GLIBC_2.2.5"); +__asm__(".symver xdr_keydat,xdr_keydat@GLIBC_2.2.5"); +__asm__(".symver xdr_mapname,xdr_mapname@GLIBC_2.2.5"); +__asm__(".symver xdr_netobj,xdr_netobj@GLIBC_2.2.5"); +__asm__(".symver xdr_obj_p,xdr_obj_p@GLIBC_2.2.5"); +__asm__(".symver xdr_opaque,xdr_opaque@GLIBC_2.2.5"); +__asm__(".symver xdr_peername,xdr_peername@GLIBC_2.2.5"); +__asm__(".symver xdr_pointer,xdr_pointer@GLIBC_2.2.5"); +__asm__(".symver xdr_sizeof,xdr_sizeof@GLIBC_2.2.5"); +__asm__(".symver xdr_string,xdr_string@GLIBC_2.2.5"); +__asm__(".symver xdr_u_char,xdr_u_char@GLIBC_2.2.5"); +__asm__(".symver xdr_u_int,xdr_u_int@GLIBC_2.2.5"); +__asm__(".symver xdr_uint32_t,xdr_uint32_t@GLIBC_2.2.5"); +__asm__(".symver xdr_valdat,xdr_valdat@GLIBC_2.2.5"); +__asm__(".symver xdr_void,xdr_void@GLIBC_2.2.5"); +__asm__(".symver xdr_yp_buf,xdr_yp_buf@GLIBC_2.2.5"); +__asm__(".symver xdr_ypall,xdr_ypall@GLIBC_2.2.5"); +__asm__(".symver xdr_ypbind_binding,xdr_ypbind_binding@GLIBC_2.2.5"); +__asm__(".symver xdr_ypbind_resp,xdr_ypbind_resp@GLIBC_2.2.5"); +__asm__(".symver xdr_ypbind_resptype,xdr_ypbind_resptype@GLIBC_2.2.5"); +__asm__(".symver xdr_ypbind_setdom,xdr_ypbind_setdom@GLIBC_2.2.5"); +__asm__(".symver xdr_ypdelete_args,xdr_ypdelete_args@GLIBC_2.2.5"); +__asm__(".symver xdr_ypmap_parms,xdr_ypmap_parms@GLIBC_2.2.5"); +__asm__(".symver xdr_ypmaplist,xdr_ypmaplist@GLIBC_2.2.5"); +__asm__(".symver xdr_yppush_status,xdr_yppush_status@GLIBC_2.2.5"); +__asm__(".symver xdr_yppushresp_xfr,xdr_yppushresp_xfr@GLIBC_2.2.5"); +__asm__(".symver xdr_ypreq_key,xdr_ypreq_key@GLIBC_2.2.5"); +__asm__(".symver xdr_ypreq_nokey,xdr_ypreq_nokey@GLIBC_2.2.5"); +__asm__(".symver xdr_ypreq_xfr,xdr_ypreq_xfr@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_all,xdr_ypresp_all@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_key_val,xdr_ypresp_key_val@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_maplist,xdr_ypresp_maplist@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_master,xdr_ypresp_master@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_order,xdr_ypresp_order@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_val,xdr_ypresp_val@GLIBC_2.2.5"); +__asm__(".symver xdr_ypresp_xfr,xdr_ypresp_xfr@GLIBC_2.2.5"); +__asm__(".symver xdr_ypstat,xdr_ypstat@GLIBC_2.2.5"); +__asm__(".symver xdr_ypupdate_args,xdr_ypupdate_args@GLIBC_2.2.5"); +__asm__(".symver xdr_ypxfrstat,xdr_ypxfrstat@GLIBC_2.2.5"); +__asm__(".symver xdrmem_create,xdrmem_create@GLIBC_2.2.5"); +__asm__(".symver xdrstdio_create,xdrstdio_create@GLIBC_2.2.5"); +__asm__(".symver xprt_unregister,xprt_unregister@GLIBC_2.2.5"); +__asm__(".symver y0,y0@GLIBC_2.2.5"); +__asm__(".symver y0f,y0f@GLIBC_2.2.5"); +__asm__(".symver y0l,y0l@GLIBC_2.2.5"); +__asm__(".symver y1,y1@GLIBC_2.2.5"); +__asm__(".symver y1f,y1f@GLIBC_2.2.5"); +__asm__(".symver y1l,y1l@GLIBC_2.2.5"); +__asm__(".symver yn,yn@GLIBC_2.2.5"); +__asm__(".symver ynf,ynf@GLIBC_2.2.5"); +__asm__(".symver ynl,ynl@GLIBC_2.2.5"); +__asm__(".symver yp_all,yp_all@GLIBC_2.2.5"); +__asm__(".symver yp_bind,yp_bind@GLIBC_2.2.5"); +__asm__(".symver yp_first,yp_first@GLIBC_2.2.5"); +__asm__(".symver yp_get_default_domain,yp_get_default_domain@GLIBC_2.2.5"); +__asm__(".symver yp_maplist,yp_maplist@GLIBC_2.2.5"); +__asm__(".symver yp_master,yp_master@GLIBC_2.2.5"); +__asm__(".symver yp_match,yp_match@GLIBC_2.2.5"); +__asm__(".symver yp_next,yp_next@GLIBC_2.2.5"); +__asm__(".symver yp_order,yp_order@GLIBC_2.2.5"); +__asm__(".symver yp_unbind,yp_unbind@GLIBC_2.2.5"); +__asm__(".symver yp_update,yp_update@GLIBC_2.2.5"); +__asm__(".symver ypbinderr_string,ypbinderr_string@GLIBC_2.2.5"); +__asm__(".symver yperr_string,yperr_string@GLIBC_2.2.5"); +__asm__(".symver ypprot_err,ypprot_err@GLIBC_2.2.5"); +__asm__(".symver __acosf128_finite,__acosf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __acoshf128_finite,__acoshf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __asinf128_finite,__asinf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __atan2f128_finite,__atan2f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __atanhf128_finite,__atanhf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __coshf128_finite,__coshf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __exp10f128_finite,__exp10f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __exp2f128_finite,__exp2f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __expf128_finite,__expf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __explicit_bzero_chk,__explicit_bzero_chk@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __finitef128,__finitef128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __fmodf128_finite,__fmodf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __fpclassifyf128,__fpclassifyf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __gammaf128_r_finite,__gammaf128_r_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __hypotf128_finite,__hypotf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __iscanonicall,__iscanonicall@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __iseqsig,__iseqsig@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __iseqsigf,__iseqsigf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __iseqsigf128,__iseqsigf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __iseqsigl,__iseqsigl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __isinff128,__isinff128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __isnanf128,__isnanf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __issignalingf128,__issignalingf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __j0f128_finite,__j0f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __j1f128_finite,__j1f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __jnf128_finite,__jnf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __lgammaf128_r_finite,__lgammaf128_r_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __log10f128_finite,__log10f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __log2f128_finite,__log2f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __logf128_finite,__logf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __powf128_finite,__powf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __remainderf128_finite,__remainderf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __rpc_thread_createerr,__rpc_thread_createerr@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __rpc_thread_svc_fdset,__rpc_thread_svc_fdset@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __secure_getenv,__secure_getenv@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __signbitf128,__signbitf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __sinhf128_finite,__sinhf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __sqrtf128_finite,__sqrtf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __strtof128_internal,__strtof128_internal@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __wcstof128_internal,__wcstof128_internal@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __y0f128_finite,__y0f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __y1f128_finite,__y1f128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver __ynf128_finite,__ynf128_finite@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver _authenticate,_authenticate@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver _null_auth,_null_auth@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver _rpc_dtablesize,_rpc_dtablesize@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver _seterr_reply,_seterr_reply@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acosf128,acosf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acosf32,acosf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acosf32x,acosf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acosf64,acosf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acosf64x,acosf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acoshf128,acoshf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acoshf32,acoshf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acoshf32x,acoshf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acoshf64,acoshf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver acoshf64x,acoshf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver advance,advance@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinf128,asinf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinf32,asinf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinf32x,asinf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinf64,asinf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinf64x,asinf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinhf128,asinhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinhf32,asinhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinhf32x,asinhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinhf64,asinhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver asinhf64x,asinhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atan2f128,atan2f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atan2f32,atan2f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atan2f32x,atan2f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atan2f64,atan2f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atan2f64x,atan2f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanf128,atanf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanf32,atanf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanf32x,atanf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanf64,atanf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanf64x,atanf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanhf128,atanhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanhf32,atanhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanhf32x,atanhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanhf64,atanhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver atanhf64x,atanhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver authdes_getucred,authdes_getucred@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver authnone_create,authnone_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver authunix_create,authunix_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver bdflush,bdflush@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cabsf128,cabsf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cabsf32,cabsf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cabsf32x,cabsf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cabsf64,cabsf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cabsf64x,cabsf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacosf128,cacosf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacosf32,cacosf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacosf32x,cacosf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacosf64,cacosf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacosf64x,cacosf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacoshf128,cacoshf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacoshf32,cacoshf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacoshf32x,cacoshf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacoshf64,cacoshf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cacoshf64x,cacoshf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver callrpc,callrpc@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalize,canonicalize@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizef,canonicalizef@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizef128,canonicalizef128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizef32,canonicalizef32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizef32x,canonicalizef32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizef64,canonicalizef64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizef64x,canonicalizef64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver canonicalizel,canonicalizel@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cargf128,cargf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cargf32,cargf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cargf32x,cargf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cargf64,cargf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cargf64x,cargf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinf128,casinf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinf32,casinf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinf32x,casinf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinf64,casinf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinf64x,casinf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinhf128,casinhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinhf32,casinhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinhf32x,casinhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinhf64,casinhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver casinhf64x,casinhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanf128,catanf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanf32,catanf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanf32x,catanf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanf64,catanf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanf64x,catanf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanhf128,catanhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanhf32,catanhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanhf32x,catanhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanhf64,catanhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver catanhf64x,catanhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cbc_crypt,cbc_crypt@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cbrtf128,cbrtf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cbrtf32,cbrtf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cbrtf32x,cbrtf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cbrtf64,cbrtf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cbrtf64x,cbrtf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccosf128,ccosf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccosf32,ccosf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccosf32x,ccosf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccosf64,ccosf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccosf64x,ccosf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccoshf128,ccoshf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccoshf32,ccoshf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccoshf32x,ccoshf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccoshf64,ccoshf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ccoshf64x,ccoshf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ceilf128,ceilf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ceilf32,ceilf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ceilf32x,ceilf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ceilf64,ceilf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ceilf64x,ceilf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cexpf128,cexpf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cexpf32,cexpf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cexpf32x,cexpf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cexpf64,cexpf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cexpf64x,cexpf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cimagf128,cimagf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cimagf32,cimagf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cimagf32x,cimagf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cimagf64,cimagf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cimagf64x,cimagf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clnt_broadcast,clnt_broadcast@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clnt_perrno,clnt_perrno@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clnt_spcreateerror,clnt_spcreateerror@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clnt_sperror,clnt_sperror@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clntraw_create,clntraw_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clntudp_bufcreate,clntudp_bufcreate@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clntunix_create,clntunix_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clog10f128,clog10f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clog10f32,clog10f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clog10f32x,clog10f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clog10f64,clog10f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clog10f64x,clog10f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clogf128,clogf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clogf32,clogf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clogf32x,clogf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clogf64,clogf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver clogf64x,clogf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver conjf128,conjf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver conjf32,conjf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver conjf32x,conjf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver conjf64,conjf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver conjf64x,conjf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver copy_file_range,copy_file_range@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver copysignf128,copysignf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver copysignf32,copysignf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver copysignf32x,copysignf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver copysignf64,copysignf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver copysignf64x,copysignf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cosf128,cosf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cosf32,cosf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cosf32x,cosf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cosf64,cosf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cosf64x,cosf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver coshf128,coshf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver coshf32,coshf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver coshf32x,coshf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver coshf64,coshf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver coshf64x,coshf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cpowf128,cpowf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cpowf32,cpowf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cpowf32x,cpowf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cpowf64,cpowf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cpowf64x,cpowf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cprojf128,cprojf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cprojf32,cprojf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cprojf32x,cprojf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cprojf64,cprojf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver cprojf64x,cprojf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver crealf128,crealf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver crealf32,crealf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver crealf32x,crealf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver crealf64,crealf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver crealf64x,crealf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver create_module,create_module@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinf128,csinf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinf32,csinf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinf32x,csinf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinf64,csinf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinf64x,csinf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinhf128,csinhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinhf32,csinhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinhf32x,csinhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinhf64,csinhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csinhf64x,csinhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csqrtf128,csqrtf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csqrtf32,csqrtf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csqrtf32x,csqrtf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csqrtf64,csqrtf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver csqrtf64x,csqrtf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanf128,ctanf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanf32,ctanf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanf32x,ctanf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanf64,ctanf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanf64x,ctanf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanhf128,ctanhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanhf32,ctanhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanhf32x,ctanhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanhf64,ctanhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ctanhf64x,ctanhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver des_setparity,des_setparity@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ecb_crypt,ecb_crypt@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erfcf128,erfcf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erfcf32,erfcf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erfcf32x,erfcf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erfcf64,erfcf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erfcf64x,erfcf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erff128,erff128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erff32,erff32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erff32x,erff32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erff64,erff64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver erff64x,erff64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp10f128,exp10f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp10f32,exp10f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp10f32x,exp10f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp10f64,exp10f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp10f64x,exp10f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp2f128,exp2f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp2f32,exp2f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp2f32x,exp2f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp2f64,exp2f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver exp2f64x,exp2f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expf128,expf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expf32,expf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expf32x,expf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expf64,expf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expf64x,expf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver explicit_bzero,explicit_bzero@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expm1f128,expm1f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expm1f32,expm1f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expm1f32x,expm1f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expm1f64,expm1f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver expm1f64x,expm1f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fabsf128,fabsf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fabsf32,fabsf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fabsf32x,fabsf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fabsf64,fabsf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fabsf64x,fabsf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fdimf128,fdimf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fdimf32,fdimf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fdimf32x,fdimf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fdimf64,fdimf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fdimf64x,fdimf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fegetmode,fegetmode@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fesetexcept,fesetexcept@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fesetmode,fesetmode@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fetestexceptflag,fetestexceptflag@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver floorf128,floorf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver floorf32,floorf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver floorf32x,floorf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver floorf64,floorf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver floorf64x,floorf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaf128,fmaf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaf32,fmaf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaf32x,fmaf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaf64,fmaf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaf64x,fmaf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxf128,fmaxf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxf32,fmaxf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxf32x,fmaxf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxf64,fmaxf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxf64x,fmaxf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmag,fmaxmag@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagf,fmaxmagf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagf128,fmaxmagf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagf32,fmaxmagf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagf32x,fmaxmagf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagf64,fmaxmagf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagf64x,fmaxmagf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmaxmagl,fmaxmagl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminf128,fminf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminf32,fminf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminf32x,fminf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminf64,fminf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminf64x,fminf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmag,fminmag@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagf,fminmagf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagf128,fminmagf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagf32,fminmagf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagf32x,fminmagf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagf64,fminmagf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagf64x,fminmagf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fminmagl,fminmagl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmodf128,fmodf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmodf32,fmodf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmodf32x,fmodf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmodf64,fmodf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fmodf64x,fmodf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver frexpf128,frexpf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver frexpf32,frexpf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver frexpf32x,frexpf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver frexpf64,frexpf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver frexpf64x,frexpf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfp,fromfp@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpf,fromfpf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpf128,fromfpf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpf32,fromfpf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpf32x,fromfpf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpf64,fromfpf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpf64x,fromfpf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpl,fromfpl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpx,fromfpx@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxf,fromfpxf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxf128,fromfpxf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxf32,fromfpxf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxf32x,fromfpxf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxf64,fromfpxf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxf64x,fromfpxf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver fromfpxl,fromfpxl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver get_kernel_syms,get_kernel_syms@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getentropy,getentropy@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getnetname,getnetname@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayload,getpayload@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadf,getpayloadf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadf128,getpayloadf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadf32,getpayloadf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadf32x,getpayloadf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadf64,getpayloadf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadf64x,getpayloadf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpayloadl,getpayloadl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getpublickey,getpublickey@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getrandom,getrandom@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver getsecretkey,getsecretkey@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver hypotf128,hypotf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver hypotf32,hypotf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver hypotf32x,hypotf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver hypotf64,hypotf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver hypotf64x,hypotf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ilogbf128,ilogbf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ilogbf32,ilogbf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ilogbf32x,ilogbf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ilogbf64,ilogbf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ilogbf64x,ilogbf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j0f128,j0f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j0f32,j0f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j0f32x,j0f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j0f64,j0f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j0f64x,j0f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j1f128,j1f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j1f32,j1f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j1f32x,j1f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j1f64,j1f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver j1f64x,j1f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver jnf128,jnf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver jnf32,jnf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver jnf32x,jnf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver jnf64,jnf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver jnf64x,jnf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_decryptsession,key_decryptsession@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_decryptsession_pk,key_decryptsession_pk@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_encryptsession,key_encryptsession@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_encryptsession_pk,key_encryptsession_pk@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_get_conv,key_get_conv@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_setnet,key_setnet@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver key_setsecret,key_setsecret@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ldexpf128,ldexpf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ldexpf32,ldexpf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ldexpf32x,ldexpf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ldexpf64,ldexpf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ldexpf64x,ldexpf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf128,lgammaf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf128_r,lgammaf128_r@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf32,lgammaf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf32_r,lgammaf32_r@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf32x,lgammaf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf32x_r,lgammaf32x_r@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf64,lgammaf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf64_r,lgammaf64_r@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf64x,lgammaf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lgammaf64x_r,lgammaf64x_r@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogb,llogb@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbf,llogbf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbf128,llogbf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbf32,llogbf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbf32x,llogbf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbf64,llogbf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbf64x,llogbf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llogbl,llogbl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llrintf128,llrintf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llrintf32,llrintf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llrintf32x,llrintf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llrintf64,llrintf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llrintf64x,llrintf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llroundf128,llroundf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llroundf32,llroundf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llroundf32x,llroundf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llroundf64,llroundf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver llroundf64x,llroundf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver loc1,loc1@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver loc2,loc2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver locs,locs@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log10f128,log10f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log10f32,log10f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log10f32x,log10f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log10f64,log10f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log10f64x,log10f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log1pf128,log1pf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log1pf32,log1pf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log1pf32x,log1pf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log1pf64,log1pf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log1pf64x,log1pf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log2f128,log2f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log2f32,log2f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log2f32x,log2f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log2f64,log2f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver log2f64x,log2f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logbf128,logbf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logbf32,logbf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logbf32x,logbf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logbf64,logbf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logbf64x,logbf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logf128,logf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logf32,logf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logf32x,logf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logf64,logf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver logf64x,logf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lrintf128,lrintf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lrintf32,lrintf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lrintf32x,lrintf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lrintf64,lrintf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lrintf64x,lrintf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lroundf128,lroundf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lroundf32,lroundf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lroundf32x,lroundf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lroundf64,lroundf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver lroundf64x,lroundf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver memfd_create,memfd_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver mlock2,mlock2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver modff128,modff128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver modff32,modff32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver modff32x,modff32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver modff64,modff64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver modff64x,modff64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nanf128,nanf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nanf32,nanf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nanf32x,nanf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nanf64,nanf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nanf64x,nanf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nearbyintf128,nearbyintf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nearbyintf32,nearbyintf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nearbyintf32x,nearbyintf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nearbyintf64,nearbyintf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nearbyintf64x,nearbyintf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver netname2host,netname2host@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver netname2user,netname2user@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextafterf128,nextafterf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextafterf32,nextafterf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextafterf32x,nextafterf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextafterf64,nextafterf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextafterf64x,nextafterf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdown,nextdown@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownf,nextdownf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownf128,nextdownf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownf32,nextdownf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownf32x,nextdownf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownf64,nextdownf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownf64x,nextdownf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextdownl,nextdownl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextup,nextup@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupf,nextupf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupf128,nextupf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupf32,nextupf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupf32x,nextupf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupf64,nextupf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupf64x,nextupf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver nextupl,nextupl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver passwd2des,passwd2des@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pkey_alloc,pkey_alloc@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pkey_free,pkey_free@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pkey_get,pkey_get@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pkey_mprotect,pkey_mprotect@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pkey_set,pkey_set@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pmap_getmaps,pmap_getmaps@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pmap_getport,pmap_getport@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pmap_rmtcall,pmap_rmtcall@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pmap_set,pmap_set@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pmap_unset,pmap_unset@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver powf128,powf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver powf32,powf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver powf32x,powf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver powf64,powf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver powf64x,powf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver preadv2,preadv2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver preadv64v2,preadv64v2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pwritev2,pwritev2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver pwritev64v2,pwritev64v2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver query_module,query_module@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver reallocarray,reallocarray@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver registerrpc,registerrpc@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remainderf128,remainderf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remainderf32,remainderf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remainderf32x,remainderf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remainderf64,remainderf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remainderf64x,remainderf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remquof128,remquof128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remquof32,remquof32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remquof32x,remquof32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remquof64,remquof64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver remquof64x,remquof64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver rintf128,rintf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver rintf32,rintf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver rintf32x,rintf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver rintf64,rintf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver rintf64x,rintf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundeven,roundeven@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenf,roundevenf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenf128,roundevenf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenf32,roundevenf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenf32x,roundevenf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenf64,roundevenf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenf64x,roundevenf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundevenl,roundevenl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundf128,roundf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundf32,roundf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundf32x,roundf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundf64,roundf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver roundf64x,roundf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver rtime,rtime@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalblnf128,scalblnf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalblnf32,scalblnf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalblnf32x,scalblnf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalblnf64,scalblnf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalblnf64x,scalblnf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalbnf128,scalbnf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalbnf32,scalbnf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalbnf32x,scalbnf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalbnf64,scalbnf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver scalbnf64x,scalbnf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayload,setpayload@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadf,setpayloadf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadf128,setpayloadf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadf32,setpayloadf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadf32x,setpayloadf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadf64,setpayloadf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadf64x,setpayloadf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadl,setpayloadl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsig,setpayloadsig@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigf,setpayloadsigf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigf128,setpayloadsigf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigf32,setpayloadsigf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigf32x,setpayloadsigf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigf64,setpayloadsigf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigf64x,setpayloadsigf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver setpayloadsigl,setpayloadsigl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sigvec,sigvec@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sincosf128,sincosf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sincosf32,sincosf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sincosf32x,sincosf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sincosf64,sincosf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sincosf64x,sincosf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinf128,sinf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinf32,sinf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinf32x,sinf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinf64,sinf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinf64x,sinf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinhf128,sinhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinhf32,sinhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinhf32x,sinhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinhf64,sinhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sinhf64x,sinhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sqrtf128,sqrtf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sqrtf32,sqrtf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sqrtf32x,sqrtf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sqrtf64,sqrtf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver sqrtf64x,sqrtf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver step,step@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromd,strfromd@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromf,strfromf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromf128,strfromf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromf32,strfromf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromf32x,strfromf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromf64,strfromf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfromf64x,strfromf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strfroml,strfroml@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof128,strtof128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof128_l,strtof128_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof32,strtof32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof32_l,strtof32_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof32x,strtof32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof32x_l,strtof32x_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof64,strtof64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof64_l,strtof64_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof64x,strtof64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver strtof64x_l,strtof64x_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svc_exit,svc_exit@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svc_getreq,svc_getreq@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svc_getreq_common,svc_getreq_common@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svc_getreqset,svc_getreqset@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svc_run,svc_run@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svc_unregister,svc_unregister@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcerr_auth,svcerr_auth@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcerr_noprog,svcerr_noprog@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcerr_progvers,svcerr_progvers@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcerr_weakauth,svcerr_weakauth@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcfd_create,svcfd_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcraw_create,svcraw_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcudp_create,svcudp_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcudp_enablecache,svcudp_enablecache@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcunix_create,svcunix_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver svcunixfd_create,svcunixfd_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanf128,tanf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanf32,tanf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanf32x,tanf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanf64,tanf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanf64x,tanf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanhf128,tanhf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanhf32,tanhf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanhf32x,tanhf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanhf64,tanhf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tanhf64x,tanhf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tgammaf128,tgammaf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tgammaf32,tgammaf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tgammaf32x,tgammaf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tgammaf64,tgammaf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver tgammaf64x,tgammaf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorder,totalorder@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderf,totalorderf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderf128,totalorderf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderf32,totalorderf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderf32x,totalorderf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderf64,totalorderf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderf64x,totalorderf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalorderl,totalorderl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermag,totalordermag@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagf,totalordermagf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagf128,totalordermagf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagf32,totalordermagf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagf32x,totalordermagf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagf64,totalordermagf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagf64x,totalordermagf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver totalordermagl,totalordermagl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver truncf128,truncf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver truncf32,truncf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver truncf32x,truncf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver truncf64,truncf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver truncf64x,truncf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfp,ufromfp@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpf,ufromfpf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpf128,ufromfpf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpf32,ufromfpf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpf32x,ufromfpf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpf64,ufromfpf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpf64x,ufromfpf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpl,ufromfpl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpx,ufromfpx@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxf,ufromfpxf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxf128,ufromfpxf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxf32,ufromfpxf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxf32x,ufromfpxf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxf64,ufromfpxf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxf64x,ufromfpxf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ufromfpxl,ufromfpxl@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver uselib,uselib@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver user2netname,user2netname@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof128,wcstof128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof128_l,wcstof128_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof32,wcstof32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof32_l,wcstof32_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof32x,wcstof32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof32x_l,wcstof32x_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof64,wcstof64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof64_l,wcstof64_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof64x,wcstof64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver wcstof64x_l,wcstof64x_l@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_accepted_reply,xdr_accepted_reply@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_authdes_cred,xdr_authdes_cred@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_authdes_verf,xdr_authdes_verf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_authunix_parms,xdr_authunix_parms@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_callhdr,xdr_callhdr@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_callmsg,xdr_callmsg@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_char,xdr_char@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_cryptkeyarg,xdr_cryptkeyarg@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_cryptkeyarg2,xdr_cryptkeyarg2@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_cryptkeyres,xdr_cryptkeyres@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_des_block,xdr_des_block@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_double,xdr_double@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_float,xdr_float@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_getcredres,xdr_getcredres@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_hyper,xdr_hyper@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_int16_t,xdr_int16_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_int32_t,xdr_int32_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_int64_t,xdr_int64_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_int8_t,xdr_int8_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_key_netstarg,xdr_key_netstarg@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_key_netstres,xdr_key_netstres@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_keybuf,xdr_keybuf@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_keystatus,xdr_keystatus@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_long,xdr_long@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_longlong_t,xdr_longlong_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_netnamestr,xdr_netnamestr@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_opaque_auth,xdr_opaque_auth@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_pmap,xdr_pmap@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_pmaplist,xdr_pmaplist@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_quad_t,xdr_quad_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_reference,xdr_reference@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_rejected_reply,xdr_rejected_reply@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_replymsg,xdr_replymsg@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_rmtcall_args,xdr_rmtcall_args@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_rmtcallres,xdr_rmtcallres@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_short,xdr_short@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_u_hyper,xdr_u_hyper@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_u_long,xdr_u_long@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_u_longlong_t,xdr_u_longlong_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_u_quad_t,xdr_u_quad_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_u_short,xdr_u_short@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_uint16_t,xdr_uint16_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_uint64_t,xdr_uint64_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_uint8_t,xdr_uint8_t@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_union,xdr_union@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_unixcred,xdr_unixcred@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_vector,xdr_vector@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdr_wrapstring,xdr_wrapstring@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdrrec_create,xdrrec_create@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdrrec_endofrecord,xdrrec_endofrecord@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdrrec_eof,xdrrec_eof@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xdrrec_skiprecord,xdrrec_skiprecord@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xencrypt,xencrypt@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver xprt_register,xprt_register@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y0f128,y0f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y0f32,y0f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y0f32x,y0f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y0f64,y0f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y0f64x,y0f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y1f128,y1f128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y1f32,y1f32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y1f32x,y1f32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y1f64,y1f64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver y1f64x,y1f64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ynf128,ynf128@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ynf32,ynf32@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ynf32x,ynf32x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ynf64,ynf64@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +__asm__(".symver ynf64x,ynf64x@GLIBC_WRAP_ERROR_SYMBOL_NOT_PRESENT_IN_REQUESTED_VERSION"); +#endif diff --git a/plugin.mk b/plugin.mk index f0a92dda..d95ed734 100644 --- a/plugin.mk +++ b/plugin.mk @@ -23,6 +23,8 @@ ifdef ARCH_LIN LDFLAGS += -shared TARGET := plugin.so RACK_USER_DIR ?= $(HOME)/.Rack + # Link to glibc 2.23 + FLAGS += -include $(RACK_DIR)/include/force_link_glibc_2.23.h endif ifdef ARCH_MAC From 997b67f5aadaa85505256f70d2cd8eb349617b28 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 13 May 2019 13:00:53 -0400 Subject: [PATCH 29/41] Add reference to new signed certificate for Mac dist. --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 2049d0bd..afa922a2 100644 --- a/Makefile +++ b/Makefile @@ -124,7 +124,7 @@ ifdef ARCH_MAC cp plugins/Fundamental/dist/*.zip dist/$(TARGET).app/Contents/Resources/Fundamental.zip # Clean up and sign bundle xattr -cr dist/$(TARGET).app - codesign --sign "VCV" --verbose dist/$(TARGET).app + codesign --sign "Developer ID Application: Andrew Belt (VRF26934X5)" --verbose dist/$(TARGET).app codesign --verify --verbose dist/$(TARGET).app spctl --assess --verbose dist/$(TARGET).app # Make ZIP From 71fab3da71e2bf1187033f035b0576f6e08b1fa2 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 13 May 2019 13:13:15 -0400 Subject: [PATCH 30/41] Fix broken eucMod() --- include/math.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/math.hpp b/include/math.hpp index 7a75df4c..96cacccd 100644 --- a/include/math.hpp +++ b/include/math.hpp @@ -120,7 +120,7 @@ inline float normalizeZero(float x) { See https://en.wikipedia.org/wiki/Euclidean_division. */ inline float eucMod(float a, float b) { - int mod = std::fmod(a, b); + float mod = std::fmod(a, b); if (mod < 0.f) { mod += b; } From 09c85276d6d8ef217a53e54856296bde6983b511 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 13 May 2019 13:52:36 -0400 Subject: [PATCH 31/41] Use linear scaling for Light value. --- include/engine/Light.hpp | 6 +++--- src/app/ModuleLightWidget.cpp | 12 ++++++------ src/engine/Engine.cpp | 10 ++++++---- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/include/engine/Light.hpp b/include/engine/Light.hpp index 46029b2c..2a2ba504 100644 --- a/include/engine/Light.hpp +++ b/include/engine/Light.hpp @@ -14,16 +14,16 @@ struct Light { /** Sets the brightness immediately with no light decay. */ void setBrightness(float brightness) { - value = (brightness > 0.f) ? std::pow(brightness, 2) : 0.f; + value = (brightness > 0.f) ? brightness : 0.f; } float getBrightness() { - return std::sqrt(value); + return value; } /** Emulates light decay with slow fall but immediate rise. */ void setSmoothBrightness(float brightness, float deltaTime) { - float v = (brightness > 0.f) ? std::pow(brightness, 2) : 0.f; + float v = (brightness > 0.f) ? brightness : 0.f; if (v < value) { // Fade out light const float lambda = 30.f; diff --git a/src/app/ModuleLightWidget.cpp b/src/app/ModuleLightWidget.cpp index c1f0aec5..34977ae5 100644 --- a/src/app/ModuleLightWidget.cpp +++ b/src/app/ModuleLightWidget.cpp @@ -12,13 +12,13 @@ void ModuleLightWidget::step() { assert(module->lights.size() >= firstLightId + baseColors.size()); for (size_t i = 0; i < baseColors.size(); i++) { - float brightness = module->lights[firstLightId + i].getBrightness(); - if (!std::isfinite(brightness)) - brightness = 0.f; + float b = module->lights[firstLightId + i].getBrightness(); + if (!std::isfinite(b)) + b = 0.f; + b = math::clamp(b, 0.f, 1.f); // Because LEDs are nonlinear, this seems to look more natural. - brightness = std::sqrt(brightness); - brightness = math::clamp(brightness, 0.f, 1.f); - brightnesses[i] = brightness; + b = std::sqrt(b); + brightnesses[i] = b; } } else { diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index d9aa252c..e6f56da9 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -495,6 +495,7 @@ void Engine::addModule(Module *module) { } // Add module internal->modules.push_back(module); + // Trigger Add event module->onAdd(); // Update ParamHandles for (ParamHandle *paramHandle : internal->paramHandles) { @@ -507,6 +508,9 @@ void Engine::removeModule(Module *module) { assert(module); VIPLock vipLock(internal->vipMutex); std::lock_guard lock(internal->mutex); + // Check that the module actually exists + auto it = std::find(internal->modules.begin(), internal->modules.end(), module); + assert(it != internal->modules.end()); // If a param is being smoothed on this module, stop smoothing it immediately if (module == internal->smoothModule) { internal->smoothModule = NULL; @@ -532,11 +536,9 @@ void Engine::removeModule(Module *module) { m->rightModule = NULL; } } - // Check that the module actually exists - auto it = std::find(internal->modules.begin(), internal->modules.end(), module); - assert(it != internal->modules.end()); - // Remove the module + // Trigger Remove event module->onRemove(); + // Remove module internal->modules.erase(it); } From 7bd98943db33a972c8c1d6956558789083ff3058 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Mon, 13 May 2019 14:50:08 -0400 Subject: [PATCH 32/41] Add left/rightMessageFlipRequested to Module. --- include/engine/Module.hpp | 16 +++++++++++----- src/engine/Engine.cpp | 13 ++++++++++--- 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/include/engine/Module.hpp b/include/engine/Module.hpp index a848ffa6..89590a03 100644 --- a/include/engine/Module.hpp +++ b/include/engine/Module.hpp @@ -41,26 +41,32 @@ struct Module { int leftModuleId = -1; /** Pointer to the left Module, or NULL if nonexistent. */ Module *leftModule = NULL; - /** Double buffer for receiving messages from adjacent modules. - If this module receives messages from adjacent modules, allocate both message buffers with identical blocks of memory (arrays, structs, etc). + /** Double buffer for receiving messages from the left adjacent module. + If this module intends to receive messages from the left, allocate both message buffers with identical blocks of memory (arrays, structs, etc). Remember to free the buffer in the Module destructor. Example: leftProducerMessage = new MyModuleMessage; leftConsumerMessage = new MyModuleMessage; - At the end of each timestep, the buffers are flipped/swapped. + Modules must check a foreign module's `model` before attempting to write its message buffer. + Once the module is checked, you can reinterpret_cast its leftProducerMessage for speed. - You may choose for the Module to write to its own message buffer for consumption by other modules. - As long as this convention is followed by the left Module, this is fine. + Once you write a message, set leftMessageFlipRequested to true, to request that the messages are flipped at the end of the timestep. + Thus, message-passing has 1-sample latency. + + You may choose for the Module to write to its own message buffer for consumption by other modules, i.e. "pull" rather than "push". + As long as this convention is followed by the left module, this is fine. */ void *leftProducerMessage = NULL; void *leftConsumerMessage = NULL; + bool leftMessageFlipRequested = false; int rightModuleId = -1; Module *rightModule = NULL; void *rightProducerMessage = NULL; void *rightConsumerMessage = NULL; + bool rightMessageFlipRequested = true; /** Seconds spent in the process() method, with exponential smoothing. Only written when CPU timing is enabled, since time measurement is expensive. diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index e6f56da9..c206c72b 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -302,10 +302,17 @@ static void Engine_step(Engine *that) { for (Cable *cable : that->internal->cables) { cable->step(); } - // Swap messages of all modules + + // Flip messages for each module for (Module *module : that->internal->modules) { - std::swap(module->leftProducerMessage, module->leftConsumerMessage); - std::swap(module->rightProducerMessage, module->rightConsumerMessage); + if (module->leftMessageFlipRequested) { + std::swap(module->leftProducerMessage, module->leftConsumerMessage); + module->leftMessageFlipRequested = false; + } + if (module->rightMessageFlipRequested) { + std::swap(module->rightProducerMessage, module->rightConsumerMessage); + module->rightMessageFlipRequested = false; + } } } From cdf7a2bbfaf4b7731dab3e5936ab9e90e48e9167 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Tue, 14 May 2019 09:54:24 -0400 Subject: [PATCH 33/41] Fix serialization for unbounded Params. --- helper.py | 2 +- include/engine/Param.hpp | 3 --- src/engine/Module.cpp | 27 ++++++++++++++++++++------- src/engine/Param.cpp | 28 ---------------------------- 4 files changed, 21 insertions(+), 39 deletions(-) delete mode 100644 src/engine/Param.cpp diff --git a/helper.py b/helper.py index 0dae63e5..39e4ca0b 100755 --- a/helper.py +++ b/helper.py @@ -8,7 +8,7 @@ import xml.etree.ElementTree # Version check -f"Python 3.6 is required" +f"Python 3.6+ is required" class UserException(Exception): diff --git a/include/engine/Param.hpp b/include/engine/Param.hpp index 1a77d40c..e4de4a20 100644 --- a/include/engine/Param.hpp +++ b/include/engine/Param.hpp @@ -19,9 +19,6 @@ struct Param { void setValue(float value) { this->value = value; } - - json_t *toJson(); - void fromJson(json_t *rootJ); }; diff --git a/src/engine/Module.cpp b/src/engine/Module.cpp index 3f51fdd2..7ccebe8e 100644 --- a/src/engine/Module.cpp +++ b/src/engine/Module.cpp @@ -34,9 +34,14 @@ json_t *Module::toJson() { // params json_t *paramsJ = json_array(); - for (Param ¶m : params) { - json_t *paramJ = param.toJson(); - json_array_append_new(paramsJ, paramJ); + for (size_t paramId = 0; paramId < params.size(); paramId++) { + float value = params[paramId].getValue(); + // Set value to 0 if param is unbounded + if (!paramQuantities[paramId]->isBounded()) + value = 0.f; + + json_t *paramJ = json_real(value); + json_array_insert_new(paramsJ, paramId, paramJ); } json_object_set_new(rootJ, "params", paramsJ); @@ -67,7 +72,7 @@ void Module::fromJson(json_t *rootJ) { size_t i; json_t *paramJ; json_array_foreach(paramsJ, i, paramJ) { - uint32_t paramId = i; + size_t paramId = i; // Get paramId // Legacy v0.6.0 to = params.size()) + continue; + + // Check that param is bounded + if (!paramQuantities[paramId]->isBounded()) + continue; + + json_t *valueJ = json_object_get(rootJ, "value"); + if (valueJ) + params[paramId].setValue(json_number_value(valueJ)); } // bypass diff --git a/src/engine/Param.cpp b/src/engine/Param.cpp deleted file mode 100644 index b69a5f42..00000000 --- a/src/engine/Param.cpp +++ /dev/null @@ -1,28 +0,0 @@ -#include "engine/Param.hpp" -#include "random.hpp" -#include "math.hpp" - - -namespace rack { -namespace engine { - - -json_t *Param::toJson() { - json_t *rootJ = json_object(); - - // TODO Handle unbounded case - json_object_set_new(rootJ, "value", json_real(value)); - - return rootJ; -} - -void Param::fromJson(json_t *rootJ) { - // TODO Handle unbounded case - json_t *valueJ = json_object_get(rootJ, "value"); - if (valueJ) - value = json_number_value(valueJ); -} - - -} // namespace engine -} // namespace rack From 669ace54c6485dc68b7cb08f59040a470428fe0c Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Tue, 14 May 2019 11:38:44 -0400 Subject: [PATCH 34/41] Fix Param serialization mistake. Update template patch. --- src/engine/Module.cpp | 33 ++++++++++------ template.vcv | 90 +++++++++++++++++++++++++++++++------------ 2 files changed, 87 insertions(+), 36 deletions(-) diff --git a/src/engine/Module.cpp b/src/engine/Module.cpp index 7ccebe8e..278a3c6a 100644 --- a/src/engine/Module.cpp +++ b/src/engine/Module.cpp @@ -35,13 +35,18 @@ json_t *Module::toJson() { // params json_t *paramsJ = json_array(); for (size_t paramId = 0; paramId < params.size(); paramId++) { - float value = params[paramId].getValue(); - // Set value to 0 if param is unbounded + // Don't serialize unbounded Params if (!paramQuantities[paramId]->isBounded()) - value = 0.f; + continue; + + json_t *paramJ = json_object(); + + json_object_set_new(paramJ, "id", json_integer(paramId)); + + float value = params[paramId].getValue(); + json_object_set_new(paramJ, "value", json_real(value)); - json_t *paramJ = json_real(value); - json_array_insert_new(paramsJ, paramId, paramJ); + json_array_append(paramsJ, paramJ); } json_object_set_new(rootJ, "params", paramsJ); @@ -72,23 +77,27 @@ void Module::fromJson(json_t *rootJ) { size_t i; json_t *paramJ; json_array_foreach(paramsJ, i, paramJ) { - size_t paramId = i; // Get paramId - // Legacy v0.6.0 to = params.size()) continue; - // Check that param is bounded + // Check that the Param is bounded if (!paramQuantities[paramId]->isBounded()) continue; - json_t *valueJ = json_object_get(rootJ, "value"); + json_t *valueJ = json_object_get(paramJ, "value"); if (valueJ) params[paramId].setValue(json_number_value(valueJ)); } diff --git a/template.vcv b/template.vcv index 3d45bd45..80f23626 100644 --- a/template.vcv +++ b/template.vcv @@ -1,13 +1,22 @@ { - "version": "1.dev", + "version": "1.dev.71fab3d", "modules": [ { "plugin": "Core", - "version": "1.dev", + "version": "1.dev.7bd9894", "model": "AudioInterface", "params": [], "data": { + "audio": { + "driver": 1, + "offset": 1, + "maxChannels": 8, + "sampleRate": 44100, + "blockSize": 256 + } }, + "leftModuleId": 2, + "rightModuleId": 8, "id": 1, "pos": [ 57, @@ -20,21 +29,28 @@ "model": "VCMixer", "params": [ { + "id": 0, "value": 1.0 }, { + "id": 1, "value": 1.0 }, { + "id": 2, "value": 1.0 }, { + "id": 3, "value": 1.0 }, { + "id": 4, "value": 1.0 } ], + "leftModuleId": 7, + "rightModuleId": 1, "id": 2, "pos": [ 47, @@ -47,27 +63,36 @@ "model": "VCO", "params": [ { + "id": 0, "value": 1.0 }, { + "id": 1, "value": 1.0 }, { + "id": 2, "value": 0.0 }, { + "id": 3, "value": 0.0 }, { + "id": 4, "value": 0.0 }, { + "id": 5, "value": 0.5 }, { + "id": 6, "value": 0.0 } ], + "leftModuleId": 5, + "rightModuleId": 4, "id": 3, "pos": [ 8, @@ -80,21 +105,28 @@ "model": "VCF", "params": [ { - "value": 0.0599999949 + "id": 0, + "value": 0.0464999937 }, { + "id": 1, "value": 0.5 }, { + "id": 2, "value": 0.236999944 }, { + "id": 3, "value": 1.0 }, { + "id": 4, "value": 0.0 } ], + "leftModuleId": 3, + "rightModuleId": 6, "id": 4, "pos": [ 18, @@ -103,20 +135,22 @@ }, { "plugin": "Core", - "version": "1.dev", + "version": "1.dev.7bd9894", "model": "MIDIToCVInterface", "params": [], "data": { - "divisions": [ - 24, - 6 - ], + "channels": 1, + "polyMode": 0, + "clockDivision": 24, + "lastPitch": 8192, + "lastMod": 0, "midi": { "driver": -11, "deviceName": "QWERTY keyboard (US)", "channel": -1 } }, + "rightModuleId": 3, "id": 5, "pos": [ 0, @@ -129,18 +163,24 @@ "model": "ADSR", "params": [ { - "value": 0.25 + "id": 0, + "value": 0.247000009 }, { - "value": 0.671000004 + "id": 1, + "value": 0.725000203 }, { - "value": 0.358999938 + "id": 2, + "value": 0.361999929 }, { - "value": 0.5 + "id": 3, + "value": 0.55850035 } ], + "leftModuleId": 4, + "rightModuleId": 7, "id": 6, "pos": [ 26, @@ -153,27 +193,35 @@ "model": "Scope", "params": [ { + "id": 0, "value": 0.0 }, { + "id": 1, "value": 0.0 }, { + "id": 2, "value": 0.0 }, { + "id": 3, "value": 0.0 }, { + "id": 4, "value": 14.0 }, { + "id": 5, "value": 0.0 }, { + "id": 6, "value": 0.0 }, { + "id": 7, "value": 0.0 } ], @@ -181,6 +229,8 @@ "lissajous": 0, "external": 0 }, + "leftModuleId": 6, + "rightModuleId": 2, "id": 7, "pos": [ 34, @@ -189,10 +239,11 @@ }, { "plugin": "Core", - "version": "1.dev", + "version": "1.dev.7bd9894", "model": "Notes", "params": [], - "text": "Demo patch instructions:\n\n1. Choose an audio driver and device in the AUDIO module. \n\n2. Use the QWERTY and ZXCVB rows of your keyboard to generate MIDI notes and convert them to 1V/oct and GATE signals.\n\n3. Drag knobs up/down. Hold CTRL (CMD on Mac) while dragging to fine-tune. Right-click knobs to edit or reset their value. \n\n4. Drag cables to patch them between inputs and outputs. Stack multiple cables on outputs by holding CTRL (CMD on Mac) and dragging from an output. \n", + "leftModuleId": 1, + "text": "Demo patch instructions:\n\n1. Choose an audio driver and device in the AUDIO module.\n\n2. Use the QWERTY and ZXCVB rows of your keyboard to generate MIDI notes, which are converted to 1V/oct and GATE signals.\n\n3. Drag knobs up/down. Hold Ctrl (Cmd on Mac) while dragging to fine-tune. Right-click knobs to edit, or double-click to initialize.\n\n4. Drag cables to patch them between inputs and outputs. Stack multiple cables on outputs by holding Ctrl (Cmd on Mac) and dragging from an output.\n\n5. Right-click on an empty rack space to add new modules.", "id": 8, "pos": [ 67, @@ -200,9 +251,9 @@ ] } ], + "id": 19, "cables": [ { - "id": 1, "outputModuleId": 5, "outputId": 0, "inputModuleId": 3, @@ -210,7 +261,6 @@ "color": "#c91847" }, { - "id": 2, "outputModuleId": 3, "outputId": 2, "inputModuleId": 4, @@ -218,7 +268,6 @@ "color": "#0c8e15" }, { - "id": 3, "outputModuleId": 2, "outputId": 0, "inputModuleId": 1, @@ -226,7 +275,6 @@ "color": "#0986ad" }, { - "id": 4, "outputModuleId": 2, "outputId": 0, "inputModuleId": 1, @@ -234,7 +282,6 @@ "color": "#c9b70e" }, { - "id": 5, "outputModuleId": 6, "outputId": 0, "inputModuleId": 4, @@ -242,7 +289,6 @@ "color": "#c91847" }, { - "id": 6, "outputModuleId": 5, "outputId": 1, "inputModuleId": 6, @@ -250,7 +296,6 @@ "color": "#c9b70e" }, { - "id": 7, "outputModuleId": 6, "outputId": 0, "inputModuleId": 2, @@ -258,7 +303,6 @@ "color": "#0c8e15" }, { - "id": 8, "outputModuleId": 4, "outputId": 0, "inputModuleId": 2, @@ -266,7 +310,6 @@ "color": "#0986ad" }, { - "id": 9, "outputModuleId": 2, "outputId": 1, "inputModuleId": 7, @@ -274,7 +317,6 @@ "color": "#c9b70e" }, { - "id": 10, "outputModuleId": 5, "outputId": 6, "inputModuleId": 6, From 212404c664d1f6a349db744ef544e64d17c13d7b Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 16 May 2019 13:08:35 -0400 Subject: [PATCH 35/41] Add Widget::addChildBottom(). Change ModuleWidget::setPanel behavior. Improve event docstrings. Temporarily disable glibc 2.23 header on Linux. --- helper.py | 2 +- include/app/ModuleWidget.hpp | 3 +-- include/event.hpp | 22 +++++++++++----------- include/plugin/Model.hpp | 2 +- include/plugin/Plugin.hpp | 4 ++-- include/rack0.hpp | 2 +- include/widget/Widget.hpp | 1 + plugin.mk | 2 +- src/Core/Blank.cpp | 5 ----- src/app/ModuleWidget.cpp | 19 ++++++++++++++----- src/widget/Widget.cpp | 10 ++++++++++ 11 files changed, 43 insertions(+), 29 deletions(-) diff --git a/helper.py b/helper.py index 39e4ca0b..ffc65087 100755 --- a/helper.py +++ b/helper.py @@ -211,7 +211,7 @@ def create_module(slug, panel_filename=None, source_filename=None): with open(manifest_filename, "w") as f: json.dump(manifest, f, indent=" ") - print(f"Added {slug} to plugin.json") + print(f"Added {slug} to {manifest_filename}") # Check filenames if panel_filename and source_filename: diff --git a/include/app/ModuleWidget.hpp b/include/app/ModuleWidget.hpp index 0127215d..f0a010f6 100644 --- a/include/app/ModuleWidget.hpp +++ b/include/app/ModuleWidget.hpp @@ -4,7 +4,6 @@ #include "ui/Menu.hpp" #include "app/PortWidget.hpp" #include "app/ParamWidget.hpp" -#include "app/SvgPanel.hpp" #include "plugin/Model.hpp" #include "engine/Module.hpp" @@ -19,7 +18,7 @@ struct ModuleWidget : widget::OpaqueWidget { /** Owned. */ engine::Module *module = NULL; - SvgPanel *panel = NULL; + widget::Widget *panel = NULL; /** Note that the indexes of these vectors do not necessarily correspond with the indexes of `Module::params` etc. */ std::vector params; diff --git a/include/event.hpp b/include/event.hpp index f8953dcb..7a716b89 100644 --- a/include/event.hpp +++ b/include/event.hpp @@ -145,7 +145,7 @@ struct Button : Base, PositionBase { /** Occurs when the left mouse button is pressed a second time on the same Widget within a time duration. -Must set the Button target to receive this event. +Must consume the Button event (on left button press) to receive this event. */ struct DoubleClick : Base { }; @@ -175,28 +175,28 @@ struct HoverScroll : Base, PositionBase { /** Occurs when a Widget begins consuming the Hover event. -Must set the Hover target to receive this event. +Must consume the Hover event to receive this event. */ struct Enter : Base { }; /** Occurs when a different Widget is entered. -Must set the Hover target to receive this event. +Must consume the Hover event (when a Widget is entered) to receive this event. */ struct Leave : Base { }; /** Occurs when a Widget begins consuming the Button press event for the left mouse button. -Must set the Button target to receive this event. +Must consume the Button event (on left button press) to receive this event. */ struct Select : Base { }; /** Occurs when a different Widget is selected. -Must set the Button target to receive this event. +Must consume the Button event (on left button press, when the Widget is selected) to receive this event. */ struct Deselect : Base { }; @@ -222,21 +222,21 @@ struct DragBase : Base { }; /** Occurs when a Widget begins being dragged. -Must set the Button target to receive this event. +Must consume the Button event (on press) to receive this event. */ struct DragStart : DragBase { }; /** Occurs when a Widget stops being dragged by releasing the mouse button. -Must set the Button target to receive this event. +Must consume the Button event (on press, when the Widget drag begins) to receive this event. */ struct DragEnd : DragBase { }; /** Occurs every frame on the dragged Widget. -Must set the Button target to receive this event. +Must consume the Button event (on press, when the Widget drag begins) to receive this event. */ struct DragMove : DragBase { /** Change in mouse position since the last frame. Can be zero. */ @@ -255,7 +255,7 @@ struct DragHover : DragBase, PositionBase { }; /** Occurs when the mouse enters a Widget while dragging. -Must set the DragHover target to receive this event. +Must consume the DragHover event to receive this event. */ struct DragEnter : DragBase { /** The dragged widget */ @@ -264,7 +264,7 @@ struct DragEnter : DragBase { /** Occurs when the mouse leaves a Widget while dragging. -Must set the DragHover target to receive this event. +Must consume the DragHover event (when the Widget is entered) to receive this event. */ struct DragLeave : DragBase { /** The dragged widget */ @@ -273,7 +273,7 @@ struct DragLeave : DragBase { /** Occurs when the mouse button is released over a Widget while dragging. -Must set the Button target to receive this event. +Must consume the Button event (on release) to receive this event. */ struct DragDrop : DragBase { /** The dragged widget */ diff --git a/include/plugin/Model.hpp b/include/plugin/Model.hpp index 32fa4422..d7157d65 100644 --- a/include/plugin/Model.hpp +++ b/include/plugin/Model.hpp @@ -25,7 +25,7 @@ struct Model { Plugin *plugin = NULL; std::vector presetPaths; - /** Must be unique. Used for saving patches. Never change this. + /** Must be unique. Used for saving patches. Never change this after releasing your module. The model slug must be unique within your plugin, but it doesn't need to be unique among different plugins. */ std::string slug; diff --git a/include/plugin/Plugin.hpp b/include/plugin/Plugin.hpp index a681b481..1e61d7a7 100644 --- a/include/plugin/Plugin.hpp +++ b/include/plugin/Plugin.hpp @@ -15,12 +15,12 @@ struct Model; struct Plugin { /** A list of the models available by this plugin, add with addModel() */ std::vector models; - /** The file path of the plugin's directory */ + /** The file path to the plugin's directory */ std::string path; /** OS-dependent library handle */ void *handle = NULL; - /** Must be unique. Used for saving patches. Never change this. + /** Must be unique. Used for saving patches. Never change this after releasing your plugin. To guarantee uniqueness, it is a good idea to prefix the slug by your "company name" if available, e.g. "MyCompany-MyPlugin" */ std::string slug; diff --git a/include/rack0.hpp b/include/rack0.hpp index ad05d544..02f4a9dd 100644 --- a/include/rack0.hpp +++ b/include/rack0.hpp @@ -44,8 +44,8 @@ DEPRECATED inline float chopf(float x, float eps) {return chop(x, eps);} DEPRECATED inline float rescalef(float x, float a, float b, float yMin, float yMax) {return math::rescale(x, a, b, yMin, yMax);} DEPRECATED inline float crossf(float a, float b, float frac) {return crossfade(a, b, frac);} DEPRECATED inline float interpf(const float *p, float x) {return interpolateLinear(p, x);} -DEPRECATED inline void cmultf(float *cr, float *ci, float ar, float ai, float br, float bi) {return complexMult(cr, ci, ar, ai, br, bi);} DEPRECATED inline void complexMult(float *cr, float *ci, float ar, float ai, float br, float bi) {complexMult(ar, ai, br, bi, cr, ci);} +DEPRECATED inline void cmultf(float *cr, float *ci, float ar, float ai, float br, float bi) {return complexMult(ar, ai, br, bi, cr, ci);} //////////////////// // random diff --git a/include/widget/Widget.hpp b/include/widget/Widget.hpp index 3a74a8e5..e9fd5f70 100644 --- a/include/widget/Widget.hpp +++ b/include/widget/Widget.hpp @@ -71,6 +71,7 @@ struct Widget { Gives ownership of widget to this widget instance. */ void addChild(Widget *child); + void addChildBottom(Widget *child); /** Removes widget from list of children if it exists. Does not delete widget but transfers ownership to caller */ diff --git a/plugin.mk b/plugin.mk index d95ed734..04ee8d34 100644 --- a/plugin.mk +++ b/plugin.mk @@ -24,7 +24,7 @@ ifdef ARCH_LIN TARGET := plugin.so RACK_USER_DIR ?= $(HOME)/.Rack # Link to glibc 2.23 - FLAGS += -include $(RACK_DIR)/include/force_link_glibc_2.23.h +# FLAGS += -include $(RACK_DIR)/include/force_link_glibc_2.23.h endif ifdef ARCH_MAC diff --git a/src/Core/Blank.cpp b/src/Core/Blank.cpp index eb864d83..097500db 100644 --- a/src/Core/Blank.cpp +++ b/src/Core/Blank.cpp @@ -99,11 +99,6 @@ struct BlankWidget : ModuleWidget { setModule(module); box.size = Vec(RACK_GRID_WIDTH * 10, RACK_GRID_HEIGHT); - // Delete SvgPanel - removeChild(panel); - delete panel; - panel = NULL; - blankPanel = new BlankPanel; addChild(blankPanel); diff --git a/src/app/ModuleWidget.cpp b/src/app/ModuleWidget.cpp index dbca8c7f..76f057c1 100644 --- a/src/app/ModuleWidget.cpp +++ b/src/app/ModuleWidget.cpp @@ -2,6 +2,7 @@ #include "app/Scene.hpp" #include "engine/Engine.hpp" #include "plugin/Plugin.hpp" +#include "app/SvgPanel.hpp" #include "system.hpp" #include "asset.hpp" #include "helpers.hpp" @@ -242,9 +243,6 @@ struct ModuleDeleteItem : ui::MenuItem { ModuleWidget::ModuleWidget() { box.size = math::Vec(0, RACK_GRID_HEIGHT); - - panel = new SvgPanel; - addChild(panel); } ModuleWidget::~ModuleWidget() { @@ -424,8 +422,19 @@ void ModuleWidget::setModule(engine::Module *module) { } void ModuleWidget::setPanel(std::shared_ptr svg) { - assert(panel); - panel->setBackground(svg); + // Remove existing panel + if (panel) { + removeChild(panel); + delete panel; + panel = NULL; + } + + // Create SvgPanel + SvgPanel *svgPanel = new SvgPanel; + svgPanel->setBackground(svg); + panel = svgPanel; + addChildBottom(panel); + // Set ModuleWidget size based on panel box.size.x = std::round(panel->box.size.x / RACK_GRID_WIDTH) * RACK_GRID_WIDTH; } diff --git a/src/widget/Widget.cpp b/src/widget/Widget.cpp index 201d9464..f2a7b346 100644 --- a/src/widget/Widget.cpp +++ b/src/widget/Widget.cpp @@ -94,6 +94,16 @@ void Widget::addChild(Widget *child) { child->onAdd(eAdd); } +void Widget::addChildBottom(Widget *child) { + assert(child); + assert(!child->parent); + child->parent = this; + children.push_front(child); + // event::Add + event::Add eAdd; + child->onAdd(eAdd); +} + void Widget::removeChild(Widget *child) { assert(child); // Make sure `this` is the child's parent From 54544bbe932afc5269c579de722657382af1e923 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 16 May 2019 14:11:21 -0400 Subject: [PATCH 36/41] Use Module::Expander struct for accessing expander messages. --- include/engine/Module.hpp | 63 ++++++++++++++++++++------------------- src/app/RackWidget.cpp | 4 +-- src/engine/Engine.cpp | 55 ++++++++++++++-------------------- src/engine/Module.cpp | 12 ++++---- 4 files changed, 63 insertions(+), 71 deletions(-) diff --git a/include/engine/Module.hpp b/include/engine/Module.hpp index 89590a03..c11c3bd9 100644 --- a/include/engine/Module.hpp +++ b/include/engine/Module.hpp @@ -37,36 +37,39 @@ struct Module { std::vector lights; std::vector paramQuantities; - /** ID of the Module immediately to the left, or -1 if nonexistent. */ - int leftModuleId = -1; - /** Pointer to the left Module, or NULL if nonexistent. */ - Module *leftModule = NULL; - /** Double buffer for receiving messages from the left adjacent module. - If this module intends to receive messages from the left, allocate both message buffers with identical blocks of memory (arrays, structs, etc). - Remember to free the buffer in the Module destructor. - Example: - - leftProducerMessage = new MyModuleMessage; - leftConsumerMessage = new MyModuleMessage; - - Modules must check a foreign module's `model` before attempting to write its message buffer. - Once the module is checked, you can reinterpret_cast its leftProducerMessage for speed. - - Once you write a message, set leftMessageFlipRequested to true, to request that the messages are flipped at the end of the timestep. - Thus, message-passing has 1-sample latency. - - You may choose for the Module to write to its own message buffer for consumption by other modules, i.e. "pull" rather than "push". - As long as this convention is followed by the left module, this is fine. - */ - void *leftProducerMessage = NULL; - void *leftConsumerMessage = NULL; - bool leftMessageFlipRequested = false; - - int rightModuleId = -1; - Module *rightModule = NULL; - void *rightProducerMessage = NULL; - void *rightConsumerMessage = NULL; - bool rightMessageFlipRequested = true; + /** Represents a message-passing channel for an adjacent module. */ + struct Expander { + /** ID of the expander module, or -1 if nonexistent. */ + int moduleId = -1; + /** Pointer to the expander Module, or NULL if nonexistent. */ + Module *module = NULL; + /** Double buffer for receiving messages from the expander module. + If you intend to receive messages from an expander, allocate both message buffers with identical blocks of memory (arrays, structs, etc). + Remember to free the buffer in the Module destructor. + Example: + + rightExpander.producerMessage = new MyExpanderMessage; + rightExpander.consumerMessage = new MyExpanderMessage; + + You must check the expander module's `model` before attempting to write its message buffer. + Once the module is checked, you can reinterpret_cast its producerMessage at no performance cost. + + Producer messages are intended to be write-only. + Consumer messages are intended to be read-only. + + Once you write a message, set messageFlipRequested to true to request that the messages are flipped at the end of the timestep. + This means that message-passing has 1-sample latency. + + You may choose for your Module to instead write to its own message buffer for consumption by other modules, i.e. the expander "pulls" rather than this module "pushing". + As long as this convention is followed by the other module, this is fine. + */ + void *producerMessage = NULL; + void *consumerMessage = NULL; + bool messageFlipRequested = false; + }; + + Expander leftExpander; + Expander rightExpander; /** Seconds spent in the process() method, with exponential smoothing. Only written when CPU timing is enabled, since time measurement is expensive. diff --git a/src/app/RackWidget.cpp b/src/app/RackWidget.cpp index 05405bce..b607ead2 100644 --- a/src/app/RackWidget.cpp +++ b/src/app/RackWidget.cpp @@ -352,8 +352,8 @@ static void RackWidget_updateAdjacent(RackWidget *that) { } ModuleWidget *mw = dynamic_cast(w); - mw->module->rightModuleId = mwRight ? mwRight->module->id : -1; - mw->module->leftModuleId = mwLeft ? mwLeft->module->id : -1; + mw->module->leftExpander.moduleId = mwLeft ? mwLeft->module->id : -1; + mw->module->rightExpander.moduleId = mwRight ? mwRight->module->id : -1; } } diff --git a/src/engine/Engine.cpp b/src/engine/Engine.cpp index c206c72b..83e2e061 100644 --- a/src/engine/Engine.cpp +++ b/src/engine/Engine.cpp @@ -305,39 +305,26 @@ static void Engine_step(Engine *that) { // Flip messages for each module for (Module *module : that->internal->modules) { - if (module->leftMessageFlipRequested) { - std::swap(module->leftProducerMessage, module->leftConsumerMessage); - module->leftMessageFlipRequested = false; + if (module->leftExpander.messageFlipRequested) { + std::swap(module->leftExpander.producerMessage, module->leftExpander.consumerMessage); + module->leftExpander.messageFlipRequested = false; } - if (module->rightMessageFlipRequested) { - std::swap(module->rightProducerMessage, module->rightConsumerMessage); - module->rightMessageFlipRequested = false; + if (module->rightExpander.messageFlipRequested) { + std::swap(module->rightExpander.producerMessage, module->rightExpander.consumerMessage); + module->rightExpander.messageFlipRequested = false; } } } -static void Engine_updateAdjacent(Engine *that, Module *m) { - // Sync leftModule - if (m->leftModuleId >= 0) { - if (!m->leftModule || m->leftModule->id != m->leftModuleId) { - m->leftModule = that->getModule(m->leftModuleId); +static void Engine_updateExpander(Engine *that, Module::Expander *expander) { + if (expander->moduleId >= 0) { + if (!expander->module || expander->module->id != expander->moduleId) { + expander->module = that->getModule(expander->moduleId); } } else { - if (m->leftModule) { - m->leftModule = NULL; - } - } - - // Sync rightModule - if (m->rightModuleId >= 0) { - if (!m->rightModule || m->rightModule->id != m->rightModuleId) { - m->rightModule = that->getModule(m->rightModuleId); - } - } - else { - if (m->rightModule) { - m->rightModule = NULL; + if (expander->module) { + expander->module = NULL; } } } @@ -411,8 +398,10 @@ static void Engine_run(Engine *that) { if (!internal->paused) { std::lock_guard lock(internal->mutex); + // Update expander pointers for (Module *module : internal->modules) { - Engine_updateAdjacent(that, module); + Engine_updateExpander(that, &module->leftExpander); + Engine_updateExpander(that, &module->rightExpander); } // Step modules @@ -532,15 +521,15 @@ void Engine::removeModule(Module *module) { if (paramHandle->moduleId == module->id) paramHandle->module = NULL; } - // Update adjacent modules + // Update expander pointers for (Module *m : internal->modules) { - if (m->leftModule == module) { - m->leftModuleId = -1; - m->leftModule = NULL; + if (m->leftExpander.module == module) { + m->leftExpander.moduleId = -1; + m->leftExpander.module = NULL; } - if (m->rightModule == module) { - m->rightModuleId = -1; - m->rightModule = NULL; + if (m->rightExpander.module == module) { + m->rightExpander.moduleId = -1; + m->rightExpander.module = NULL; } } // Trigger Remove event diff --git a/src/engine/Module.cpp b/src/engine/Module.cpp index 278a3c6a..b5091ff6 100644 --- a/src/engine/Module.cpp +++ b/src/engine/Module.cpp @@ -61,12 +61,12 @@ json_t *Module::toJson() { } // leftModuleId - if (leftModuleId >= 0) - json_object_set_new(rootJ, "leftModuleId", json_integer(leftModuleId)); + if (leftExpander.moduleId >= 0) + json_object_set_new(rootJ, "leftModuleId", json_integer(leftExpander.moduleId)); // rightModuleId - if (rightModuleId >= 0) - json_object_set_new(rootJ, "rightModuleId", json_integer(rightModuleId)); + if (rightExpander.moduleId >= 0) + json_object_set_new(rootJ, "rightModuleId", json_integer(rightExpander.moduleId)); return rootJ; } @@ -115,12 +115,12 @@ void Module::fromJson(json_t *rootJ) { // leftModuleId json_t *leftModuleIdJ = json_object_get(rootJ, "leftModuleId"); if (leftModuleIdJ) - leftModuleId = json_integer_value(leftModuleIdJ); + leftExpander.moduleId = json_integer_value(leftModuleIdJ); // rightModuleId json_t *rightModuleIdJ = json_object_get(rootJ, "rightModuleId"); if (rightModuleIdJ) - rightModuleId = json_integer_value(rightModuleIdJ); + rightExpander.moduleId = json_integer_value(rightModuleIdJ); } From 076f8b196542a3b4e523730012e143df5185cf38 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Thu, 16 May 2019 21:37:52 -0400 Subject: [PATCH 37/41] Clean up ui namespace. Remove blendish state from ui classes. --- include/ui/Button.hpp | 3 --- include/ui/RadioButton.hpp | 5 ++--- include/ui/ScrollBar.hpp | 1 - include/ui/Slider.hpp | 1 - src/app/MenuBar.cpp | 5 +++++ src/ui/Button.cpp | 17 +++++++---------- src/ui/ChoiceButton.cpp | 7 +++++++ src/ui/RadioButton.cpp | 13 ++++--------- src/ui/ScrollBar.cpp | 8 ++++++-- src/ui/Slider.cpp | 8 ++++++-- 10 files changed, 37 insertions(+), 31 deletions(-) diff --git a/include/ui/Button.hpp b/include/ui/Button.hpp index 2a287dbb..5e07ec5e 100644 --- a/include/ui/Button.hpp +++ b/include/ui/Button.hpp @@ -10,14 +10,11 @@ namespace ui { struct Button : widget::OpaqueWidget { std::string text; - BNDwidgetState state = BND_DEFAULT; /** Not owned. Tracks the pressed state of the button.*/ Quantity *quantity = NULL; Button(); void draw(const DrawArgs &args) override; - void onEnter(const event::Enter &e) override; - void onLeave(const event::Leave &e) override; void onDragStart(const event::DragStart &e) override; void onDragEnd(const event::DragEnd &e) override; void onDragDrop(const event::DragDrop &e) override; diff --git a/include/ui/RadioButton.hpp b/include/ui/RadioButton.hpp index 7fceb76d..5034c55b 100644 --- a/include/ui/RadioButton.hpp +++ b/include/ui/RadioButton.hpp @@ -2,6 +2,8 @@ #include "ui/common.hpp" #include "widget/OpaqueWidget.hpp" #include "Quantity.hpp" +#include "app.hpp" +#include "event.hpp" namespace rack { @@ -9,14 +11,11 @@ namespace ui { struct RadioButton : widget::OpaqueWidget { - BNDwidgetState state = BND_DEFAULT; /** Not owned. */ Quantity *quantity = NULL; RadioButton(); void draw(const DrawArgs &args) override; - void onEnter(const event::Enter &e) override; - void onLeave(const event::Leave &e) override; void onDragDrop(const event::DragDrop &e) override; }; diff --git a/include/ui/ScrollBar.hpp b/include/ui/ScrollBar.hpp index 3c6d4908..b4a52a6e 100644 --- a/include/ui/ScrollBar.hpp +++ b/include/ui/ScrollBar.hpp @@ -14,7 +14,6 @@ struct ScrollBar : widget::OpaqueWidget { HORIZONTAL }; Orientation orientation; - BNDwidgetState state = BND_DEFAULT; float offset = 0.0; float size = 0.0; diff --git a/include/ui/Slider.hpp b/include/ui/Slider.hpp index 009c8d7d..3c3cc0af 100644 --- a/include/ui/Slider.hpp +++ b/include/ui/Slider.hpp @@ -10,7 +10,6 @@ namespace ui { struct Slider : widget::OpaqueWidget { - BNDwidgetState state = BND_DEFAULT; /** Not owned. */ Quantity *quantity = NULL; diff --git a/src/app/MenuBar.cpp b/src/app/MenuBar.cpp index c2b4c77b..f73301ab 100644 --- a/src/app/MenuBar.cpp +++ b/src/app/MenuBar.cpp @@ -28,6 +28,11 @@ struct MenuButton : ui::Button { Widget::step(); } void draw(const DrawArgs &args) override { + BNDwidgetState state = BND_DEFAULT; + if (APP->event->hoveredWidget == this) + state = BND_HOVER; + if (APP->event->draggedWidget == this) + state = BND_ACTIVE; bndMenuItem(args.vg, 0.0, 0.0, box.size.x, box.size.y, state, -1, text.c_str()); } }; diff --git a/src/ui/Button.cpp b/src/ui/Button.cpp index 7682b5fe..ec4577b0 100644 --- a/src/ui/Button.cpp +++ b/src/ui/Button.cpp @@ -1,4 +1,6 @@ #include "ui/Button.hpp" +#include "app.hpp" +#include "event.hpp" namespace rack { @@ -10,28 +12,23 @@ Button::Button() { } void Button::draw(const DrawArgs &args) { + BNDwidgetState state = BND_DEFAULT; + if (APP->event->hoveredWidget == this) + state = BND_HOVER; + if (APP->event->draggedWidget == this) + state = BND_ACTIVE; bndToolButton(args.vg, 0.0, 0.0, box.size.x, box.size.y, BND_CORNER_NONE, state, -1, text.c_str()); } -void Button::onEnter(const event::Enter &e) { - state = BND_HOVER; -} - -void Button::onLeave(const event::Leave &e) { - state = BND_DEFAULT; -} - void Button::onDragStart(const event::DragStart &e) { if (e.button != GLFW_MOUSE_BUTTON_LEFT) return; - state = BND_ACTIVE; if (quantity) quantity->setMax(); } void Button::onDragEnd(const event::DragEnd &e) { - state = BND_HOVER; if (quantity) quantity->setMin(); } diff --git a/src/ui/ChoiceButton.cpp b/src/ui/ChoiceButton.cpp index 9894dbbd..f93eb1dc 100644 --- a/src/ui/ChoiceButton.cpp +++ b/src/ui/ChoiceButton.cpp @@ -1,4 +1,6 @@ #include "ui/ChoiceButton.hpp" +#include "app.hpp" +#include "event.hpp" namespace rack { @@ -6,6 +8,11 @@ namespace ui { void ChoiceButton::draw(const DrawArgs &args) { + BNDwidgetState state = BND_DEFAULT; + if (APP->event->hoveredWidget == this) + state = BND_HOVER; + if (APP->event->draggedWidget == this) + state = BND_ACTIVE; bndChoiceButton(args.vg, 0.0, 0.0, box.size.x, box.size.y, BND_CORNER_NONE, state, -1, text.c_str()); } diff --git a/src/ui/RadioButton.cpp b/src/ui/RadioButton.cpp index 206b2d98..a9dda3d9 100644 --- a/src/ui/RadioButton.cpp +++ b/src/ui/RadioButton.cpp @@ -10,7 +10,10 @@ RadioButton::RadioButton() { } void RadioButton::draw(const DrawArgs &args) { - BNDwidgetState state = this->state; + BNDwidgetState state = BND_DEFAULT; + if (APP->event->hoveredWidget == this) + state = BND_HOVER; + std::string label; if (quantity) { label = quantity->getLabel(); @@ -20,14 +23,6 @@ void RadioButton::draw(const DrawArgs &args) { bndRadioButton(args.vg, 0.0, 0.0, box.size.x, box.size.y, BND_CORNER_NONE, state, -1, label.c_str()); } -void RadioButton::onEnter(const event::Enter &e) { - state = BND_HOVER; -} - -void RadioButton::onLeave(const event::Leave &e) { - state = BND_DEFAULT; -} - void RadioButton::onDragDrop(const event::DragDrop &e) { if (e.origin == this) { if (quantity) { diff --git a/src/ui/ScrollBar.cpp b/src/ui/ScrollBar.cpp index 0072da3a..4654d39c 100644 --- a/src/ui/ScrollBar.cpp +++ b/src/ui/ScrollBar.cpp @@ -13,6 +13,12 @@ ScrollBar::ScrollBar() { } void ScrollBar::draw(const DrawArgs &args) { + BNDwidgetState state = BND_DEFAULT; + if (APP->event->hoveredWidget == this) + state = BND_HOVER; + if (APP->event->draggedWidget == this) + state = BND_ACTIVE; + bndScrollBar(args.vg, 0.0, 0.0, box.size.x, box.size.y, state, offset, size); } @@ -20,7 +26,6 @@ void ScrollBar::onDragStart(const event::DragStart &e) { if (e.button != GLFW_MOUSE_BUTTON_LEFT) return; - state = BND_ACTIVE; APP->window->cursorLock(); } @@ -36,7 +41,6 @@ void ScrollBar::onDragMove(const event::DragMove &e) { } void ScrollBar::onDragEnd(const event::DragEnd &e) { - state = BND_DEFAULT; APP->window->cursorUnlock(); } diff --git a/src/ui/Slider.cpp b/src/ui/Slider.cpp index 2333053c..fcc2efba 100644 --- a/src/ui/Slider.cpp +++ b/src/ui/Slider.cpp @@ -13,6 +13,12 @@ Slider::Slider() { } void Slider::draw(const DrawArgs &args) { + BNDwidgetState state = BND_DEFAULT; + if (APP->event->hoveredWidget == this) + state = BND_HOVER; + if (APP->event->draggedWidget == this) + state = BND_ACTIVE; + float progress = quantity ? quantity->getScaledValue() : 0.f; std::string text = quantity ? quantity->getString() : ""; bndSlider(args.vg, 0.0, 0.0, box.size.x, box.size.y, BND_CORNER_NONE, state, progress, text.c_str(), NULL); @@ -22,7 +28,6 @@ void Slider::onDragStart(const event::DragStart &e) { if (e.button != GLFW_MOUSE_BUTTON_LEFT) return; - state = BND_ACTIVE; APP->window->cursorLock(); } @@ -33,7 +38,6 @@ void Slider::onDragMove(const event::DragMove &e) { } void Slider::onDragEnd(const event::DragEnd &e) { - state = BND_DEFAULT; APP->window->cursorUnlock(); } From 6a730b826894de351e33558f75b7a091cea9167c Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 17 May 2019 11:12:12 -0400 Subject: [PATCH 38/41] Disable plugins menubar item. --- src/app/MenuBar.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/app/MenuBar.cpp b/src/app/MenuBar.cpp index f73301ab..26b3558a 100644 --- a/src/app/MenuBar.cpp +++ b/src/app/MenuBar.cpp @@ -581,6 +581,13 @@ struct PluginsMenu : ui::Menu { void refresh() { clearChildren(); + { + ui::MenuLabel *disabledLable = new ui::MenuLabel; + disabledLable->text = "Server not yet available"; + addChild(disabledLable); + return; + } + if (plugin::isLoggedIn()) { ManageItem *manageItem = new ManageItem; manageItem->text = "Manage"; From 3fea359c221967b04a3fe865f1a8a9a1b775c11e Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 17 May 2019 11:56:17 -0400 Subject: [PATCH 39/41] Include helper.py in SDK --- Makefile | 9 +++++---- plugin.mk | 2 +- src/plugin.cpp | 1 + 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index afa922a2..09be3787 100644 --- a/Makefile +++ b/Makefile @@ -105,7 +105,7 @@ ifdef ARCH_LIN ldd dist/Rack/$(TARGET) cp plugins/Fundamental/dist/*.zip dist/Rack/Fundamental.zip # Make ZIP - cd dist && zip -q -5 -r Rack-$(VERSION)-$(ARCH).zip Rack + cd dist && zip -q -9 -r Rack-$(VERSION)-$(ARCH).zip Rack endif ifdef ARCH_MAC mkdir -p dist/$(TARGET).app @@ -128,7 +128,7 @@ ifdef ARCH_MAC codesign --verify --verbose dist/$(TARGET).app spctl --assess --verbose dist/$(TARGET).app # Make ZIP - cd dist && zip -q -5 -r Rack-$(VERSION)-$(ARCH).zip $(TARGET).app + cd dist && zip -q -9 -r Rack-$(VERSION)-$(ARCH).zip $(TARGET).app endif ifdef ARCH_WIN mkdir -p dist/Rack @@ -140,7 +140,7 @@ ifdef ARCH_WIN cp /mingw64/bin/libgcc_s_seh-1.dll dist/Rack/ cp plugins/Fundamental/dist/*.zip dist/Rack/Fundamental.zip # Make ZIP - cd dist && zip -q -5 -r Rack-$(VERSION)-$(ARCH).zip Rack + cd dist && zip -q -9 -r Rack-$(VERSION)-$(ARCH).zip Rack # Make NSIS installer # pacman -S mingw-w64-x86_64-nsis makensis -DVERSION=$(VERSION) installer.nsi @@ -154,10 +154,11 @@ endif cp -R include dist/Rack-SDK/ mkdir -p dist/Rack-SDK/dep/ cp -R dep/include dist/Rack-SDK/dep/ + cp helper.py dist/Rack-SDK/ ifdef ARCH_WIN cp libRack.a dist/Rack-SDK/ endif - cd dist && zip -q -5 -r Rack-SDK-$(VERSION).zip Rack-SDK + cd dist && zip -q -9 -r Rack-SDK-$(VERSION).zip Rack-SDK # Obviously this will only work if you have the private keys to my server diff --git a/plugin.mk b/plugin.mk index 04ee8d34..4f76e14c 100644 --- a/plugin.mk +++ b/plugin.mk @@ -64,7 +64,7 @@ endif @# Copy distributables cp -R $(DISTRIBUTABLES) dist/$(SLUG)/ @# Create ZIP package - cd dist && zip -q -5 -r $(SLUG)-$(VERSION)-$(ARCH).zip $(SLUG) + cd dist && zip -q -9 -r $(SLUG)-$(VERSION)-$(ARCH).zip $(SLUG) install: dist cp dist/$(SLUG)-$(VERSION)-$(ARCH).zip $(RACK_USER_DIR)/plugins/ diff --git a/src/plugin.cpp b/src/plugin.cpp index a4295693..0e5276f3 100644 --- a/src/plugin.cpp +++ b/src/plugin.cpp @@ -314,6 +314,7 @@ void init() { std::string fundamentalSrc = asset::system("Fundamental.zip"); std::string fundamentalDir = asset::user("plugins/Fundamental"); if (!settings::devMode && !getPlugin("Fundamental") && system::isFile(fundamentalSrc)) { + INFO("Extracting bundled Fundamental package"); extractZip(fundamentalSrc.c_str(), pluginsDir.c_str()); loadPlugin(fundamentalDir); } From 0faacb51665bc9d2404346eca6c428dad5656e26 Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 17 May 2019 12:02:22 -0400 Subject: [PATCH 40/41] Add VCV Rack Non-Commercial Plugin License Exception. --- LICENSE.md | 30 ++++++++++++------------------ 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/LICENSE.md b/LICENSE.md index a5a83f34..bd5b3566 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,33 +1,27 @@ # VCV Rack Licenses -All VCV Rack **source code** is copyright © 2019 Andrew Belt and licensed under the [GNU General Public License v3.0](LICENSE-GPLv3.txt). +All VCV Rack **source code** is copyright © 2019 Andrew Belt and licensed under the [GNU General Public License v3.0](LICENSE-GPLv3.txt) with the "VCV Rack Non-Commercial Plugin License Exception", allowed under section 7 of GPLv3, and a commercial licensing option. -``` -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. +>#### VCV Rack Non-Commercial Plugin License Exception +> +>A Plugin is defined as a software library intended to be linked and executed by this software. +> +>You are granted the permission to use this software's Application Programming Interface (API) in your Plugin in source and binary forms, as well as link to this software with the Plugin, regardless of the Plugin's license terms even if it would otherwise violate the terms of this software's GPLv3, provided that the Plugin is distributed free of charge. +> +>Derived works of this software may keep or omit this Exception. -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. +This means that non-commercial plugins do not need to be licensed under the GPLv3 and can be released under any license of your choice (open-source or proprietary freeware). However, plugins that copy a significant portion of non-API source code from Rack must be licensed under GPLv3. -You should have received a copy of the GNU General Public License -along with this program. If not, see . -``` - -A non-commercial plugin license exception and commercial plugin licensing are pending and will be available as soon as their texts are finalized (as of 2019-05-06). +Email contact@vcvrack.com for licensing your commercial plugin and/or for selling your plugin in the [VCV Plugin Manager](https://vcvrack.com/plugins.html). --- Licenses of **third-party libraries** are listed in [LICENSE-dist.txt](LICENSE-dist.txt). ---- - The **Component Library graphics** in the `res/ComponentLibrary` directory are copyright © 2019 [Grayscale](http://grayscale.info/) and licensed under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/). You may not freely sell plugins using Component Library graphics. -However, a free commercial license is available for plugins sold through the [VCV Store](https://vcvrack.com/plugins.html). -Email contact@vcvrack.com for more information about licensing or the VCV Store. +However, a free commercial license is available for plugins sold through the [VCV Plugin Manager](https://vcvrack.com/plugins.html). +Email contact@vcvrack.com for more information about licensing or the VCV Plugin Manager. The **Core panel graphics** in the `res/Core` directory are copyright © 2019 [Grayscale](http://grayscale.info/) and licensed under [CC BY-NC-ND 4.0](https://creativecommons.org/licenses/by-nc-nd/4.0/). You may not create modified adaptations of these graphics. From ddf06a9a4e2847fa46fa5da851a769860c024d7c Mon Sep 17 00:00:00 2001 From: Andrew Belt Date: Fri, 17 May 2019 12:13:14 -0400 Subject: [PATCH 41/41] Clarify commercial plugin license. --- LICENSE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE.md b/LICENSE.md index bd5b3566..95f5460c 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -12,7 +12,7 @@ All VCV Rack **source code** is copyright © 2019 Andrew Belt and licensed under This means that non-commercial plugins do not need to be licensed under the GPLv3 and can be released under any license of your choice (open-source or proprietary freeware). However, plugins that copy a significant portion of non-API source code from Rack must be licensed under GPLv3. -Email contact@vcvrack.com for licensing your commercial plugin and/or for selling your plugin in the [VCV Plugin Manager](https://vcvrack.com/plugins.html). +If you wish to release a proprietary commercial plugin, email contact@vcvrack.com for commercial licensing. A commercial license is included for plugins sold in the [VCV Plugin Manager](https://vcvrack.com/plugins.html). ---