Merge branch 'V2Baking' of git://github.com/Shyotl/SingularityViewer into V2Baking

Conflicts:
	indra/llrender/llshadermgr.cpp
	indra/newview/llmorphview.cpp
	indra/newview/lltexlayer.cpp
	indra/newview/lltexlayer.h
	indra/newview/lltoolmorph.cpp
	indra/newview/llvoavatar.cpp
	indra/newview/llvoavatar.h

.gitignore

@@ -1,5 +1,4 @@
 /installed.xml
-/indra/llcommon/llversionviewer.h
 /indra/build-*
 /indra/tools/vstool/obj/
 *.aps
@@ -12,13 +11,11 @@
 /indra/viewer-*
 /indra/newview/vivox-runtime/
 /libraries/
-/lib/
 *.pyc
 *.orig
 *.rej
 *.bak
 *~
-*.DS_Store
 /LICENSES/
 /edited-files.txt
 qtcreator-build/

LICENSES/boost.txt

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

LICENSES/dbusglib.txt

@@ -0,0 +1,550 @@
+The D-Bus glib bindings are licensed to you under your choice of the Academic
+Free License version 2.1, or the GNU General Public License version 2.  Both
+licenses are included here. Some of the standalone binaries are under the GPL
+only; in particular, but not limted to, tests/decode-gcov.c. Each source code
+file is marked with the proper copyright information.
+
+
+
+The Academic Free License
+v. 2.1
+
+This Academic Free License (the "License") applies to any original work of authorship (the "Original Work") whose owner (the "Licensor") has placed the following notice immediately following the copyright notice for the Original Work:
+
+Licensed under the Academic Free License version 2.1
+
+1) Grant of Copyright License. Licensor hereby grants You a
+world-wide, royalty-free, non-exclusive, perpetual, sublicenseable
+license to do the following:
+
+a) to reproduce the Original Work in copies;
+
+b) to prepare derivative works ("Derivative Works") based upon the Original Work;
+
+c) to distribute copies of the Original Work and Derivative Works to the public;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor hereby grants You a world-wide,
+royalty-free, non-exclusive, perpetual, sublicenseable license, under
+patent claims owned or controlled by the Licensor that are embodied in
+the Original Work as furnished by the Licensor, to make, use, sell and
+offer for sale the Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the
+preferred form of the Original Work for making modifications to it and
+all available documentation describing how to modify the Original
+Work. Licensor hereby agrees to provide a machine-readable copy of the
+Source Code of the Original Work along with each copy of the Original
+Work that Licensor distributes. Licensor reserves the right to satisfy
+this obligation by placing a machine-readable copy of the Source Code
+in an information repository reasonably calculated to permit
+inexpensive and convenient access by You for as long as Licensor
+continues to distribute the Original Work, and by publishing the
+address of that information repository in a notice immediately
+following the copyright notice that applies to the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor
+the names of any contributors to the Original Work, nor any of their
+trademarks or service marks, may be used to endorse or promote
+products derived from this Original Work without express prior written
+permission of the Licensor. Nothing in this License shall be deemed to
+grant any rights to trademarks, copyrights, patents, trade secrets or
+any other intellectual property of Licensor except as expressly stated
+herein. No patent license is granted to make, use, sell or offer to
+sell embodiments of any patent claims other than the licensed claims
+defined in Section 2. No right is granted to the trademarks of
+Licensor even if such marks are included in the Original Work. Nothing
+in this License shall be interpreted to prohibit Licensor from
+licensing under different terms from this License any Original Work
+that Licensor otherwise would have a right to license.
+
+5) This section intentionally omitted.
+
+6) Attribution Rights. You must retain, in the Source Code of any
+Derivative Works that You create, all copyright, patent or trademark
+notices from the Source Code of the Original Work, as well as any
+notices of licensing and any descriptive text identified therein as an
+"Attribution Notice." You must cause the Source Code for any
+Derivative Works that You create to carry a prominent Attribution
+Notice reasonably calculated to inform recipients that You have
+modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor
+warrants that the copyright in and to the Original Work and the patent
+rights granted herein by Licensor are owned by the Licensor or are
+sublicensed to You under the terms of this License with the permission
+of the contributor(s) of those copyrights and patent rights. Except as
+expressly stated in the immediately proceeding sentence, the Original
+Work is provided under this License on an "AS IS" BASIS and WITHOUT
+WARRANTY, either express or implied, including, without limitation,
+the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL
+WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential
+part of this License. No license to Original Work is granted hereunder
+except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal
+theory, whether in tort (including negligence), contract, or
+otherwise, shall the Licensor be liable to any person for any direct,
+indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or the use of the
+Original Work including, without limitation, damages for loss of
+goodwill, work stoppage, computer failure or malfunction, or any and
+all other commercial damages or losses. This limitation of liability
+shall not apply to liability for death or personal injury resulting
+from Licensor's negligence to the extent applicable law prohibits such
+limitation. Some jurisdictions do not allow the exclusion or
+limitation of incidental or consequential damages, so this exclusion
+and limitation may not apply to You.
+
+9) Acceptance and Termination. If You distribute copies of the
+Original Work or a Derivative Work, You must make a reasonable effort
+under the circumstances to obtain the express assent of recipients to
+the terms of this License. Nothing else but this License (or another
+written agreement between Licensor and You) grants You permission to
+create Derivative Works based upon the Original Work or to exercise
+any of the rights granted in Section 1 herein, and any attempt to do
+so except under the terms of this License (or another written
+agreement between Licensor and You) is expressly prohibited by
+U.S. copyright law, the equivalent laws of other countries, and by
+international treaty. Therefore, by exercising any of the rights
+granted to You in Section 1 herein, You indicate Your acceptance of
+this License and all of its terms and conditions.
+
+10) Termination for Patent Action. This License shall terminate
+automatically and You may no longer exercise any of the rights granted
+to You by this License as of the date You commence an action,
+including a cross-claim or counterclaim, against Licensor or any
+licensee alleging that the Original Work infringes a patent. This
+termination provision shall not apply for an action alleging patent
+infringement by combinations of the Original Work with other software
+or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating
+to this License may be brought only in the courts of a jurisdiction
+wherein the Licensor resides or in which Licensor conducts its primary
+business, and under the laws of that jurisdiction excluding its
+conflict-of-law provisions. The application of the United Nations
+Convention on Contracts for the International Sale of Goods is
+expressly excluded. Any use of the Original Work outside the scope of
+this License or after its termination shall be subject to the
+requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101
+et seq., the equivalent laws of other countries, and international
+treaty. This section shall survive the termination of this License.
+
+12) Attorneys Fees. In any action to enforce the terms of this License
+or seeking damages relating thereto, the prevailing party shall be
+entitled to recover its costs and expenses, including, without
+limitation, reasonable attorneys' fees and costs incurred in
+connection with such action, including any appeal of such action. This
+section shall survive the termination of this License.
+
+13) Miscellaneous. This License represents the complete agreement
+concerning the subject matter hereof. If any provision of this License
+is held to be unenforceable, such provision shall be reformed only to
+the extent necessary to make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this
+License, whether in upper or lower case, means an individual or a
+legal entity exercising rights under, and complying with all of the
+terms of, this License. For legal entities, "You" includes any entity
+that controls, is controlled by, or is under common control with
+you. For purposes of this definition, "control" means (i) the power,
+direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty
+percent (50%) or more of the outstanding shares, or (iii) beneficial
+ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not
+otherwise restricted or conditioned by this License or by law, and
+Licensor promises not to interfere with or be responsible for such
+uses by You.
+
+This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights
+reserved. Permission is hereby granted to copy and distribute this
+license without modification. This license may not be modified without
+the express written permission of its copyright owner.
+
+
+-- 
+END OF ACADEMIC FREE LICENSE. The following is intended to describe the essential 
+differences between the Academic Free License (AFL) version 1.0 and other 
+open source licenses:
+
+The Academic Free License is similar to the BSD, MIT, UoI/NCSA and Apache 
+licenses in many respects but it is intended to solve a few problems with 
+those licenses.
+    
+* The AFL is written so as to make it clear what software is being 
+licensed (by the inclusion of a statement following the copyright notice 
+in the software). This way, the license functions better than a template 
+license. The BSD, MIT and UoI/NCSA licenses apply to unidentified software.
+    
+* The AFL contains a complete copyright grant to the software. The BSD 
+and Apache licenses are vague and incomplete in that respect.
+    
+* The AFL contains a complete patent grant to the software. The BSD, MIT, 
+UoI/NCSA and Apache licenses rely on an implied patent license and contain 
+no explicit patent grant.
+    
+* The AFL makes it clear that no trademark rights are granted to the 
+licensor's trademarks. The Apache license contains such a provision, but the 
+BSD, MIT and UoI/NCSA licenses do not.
+    
+* The AFL includes the warranty by the licensor that it either owns the 
+copyright or that it is distributing the software under a license. None of 
+the other licenses contain that warranty. All other warranties are disclaimed, 
+as is the case for the other licenses.
+
+* The AFL is itself copyrighted (with the right granted to copy and distribute 
+without modification). This ensures that the owner of the copyright to the 
+license will control changes. The Apache license contains a copyright notice, 
+but the BSD, MIT and UoI/NCSA licenses do not. 
+--
+START OF GNU GENERAL PUBLIC LICENSE
+--
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

etc/message.xml

@@ -378,7 +378,14 @@
 					<boolean>true</boolean>
 				</map>
 
-
+				<key>ParcelMediaURLFilter</key>
+				<map>
+					<key>flavor</key>
+					<string>llsd</string>
+					<key>trusted-sender</key>
+					<boolean>false</boolean>
+				</map>
+				
 				<key>ParcelNavigateMedia</key>
 				<map>
 					<key>flavor</key>
@@ -663,19 +670,19 @@
 			<key>EstateChangeInfo</key>
 			<boolean>true</boolean>
 		
-			<key>FetchInventoryDescendents2</key>
+			<key>FetchInventoryDescendents</key>
 			<boolean>false</boolean>
 
 			<key>WebFetchInventoryDescendents</key>
 			<boolean>false</boolean>
 
-			<key>FetchInventory2</key>
+			<key>FetchInventory</key>
 			<boolean>true</boolean>
 		
-			<key>FetchLibDescendents2</key>
+			<key>FetchLibDescendents</key>
 			<boolean>true</boolean>
 		
-			<key>FetchLib2</key>
+			<key>FetchLib</key>
 			<boolean>true</boolean>
 		</map>
 

indra/CMakeLists.txt

@@ -26,11 +26,11 @@ set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 include(Variables)
 
 # Load versions now.  Install locations need them.
-include(BuildVersion)
+include(Versions)
 
 include(UnixInstall)
 
-set (DISABLE_FATAL_WARNINGS TRUE)
+set (GCC_DISABLE_FATAL_WARNINGS TRUE)
 
 if (NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE ReleaseSSE2 CACHE STRING
@@ -77,7 +77,6 @@ if (VIEWER)
   add_subdirectory(${LIBS_OPEN_PREFIX}llcrashlogger)
   add_subdirectory(${LIBS_OPEN_PREFIX}llplugin)
   add_subdirectory(${LIBS_OPEN_PREFIX}llui)
-  add_subdirectory(${LIBS_OPEN_PREFIX}llxuixml)
 
   # viewer plugins directory
   add_subdirectory(${LIBS_OPEN_PREFIX}plugins)

indra/cmake/00-Common.cmake

@@ -28,9 +28,6 @@ set(CMAKE_CONFIGURATION_TYPES "RelWithDebInfo;Release;ReleaseSSE2;Debug" CACHE S
 # Platform-specific compilation flags.
 
 if (WINDOWS)
-  # Remove default /Zm1000 flag that cmake inserts
-  string (REPLACE "/Zm1000" " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-
   # Don't build DLLs.
   set(BUILD_SHARED_LIBS OFF)
 
@@ -70,10 +67,6 @@ if (WINDOWS)
       /Oy-
       )
      
-  # configure win32 API for windows XP+ compatibility
-  set(WINVER "0x0501" CACHE STRING "Win32 API Target version (see http://msdn.microsoft.com/en-us/library/aa383745%28v=VS.85%29.aspx)")
-  add_definitions("/DWINVER=${WINVER}" "/D_WIN32_WINNT=${WINVER}")
-
   if(MSVC80 OR MSVC90 OR MSVC10)
     set(CMAKE_CXX_FLAGS_RELEASE
       "${CMAKE_CXX_FLAGS_RELEASE} -D_SECURE_STL=0 -D_HAS_ITERATOR_DEBUGGING=0"
@@ -90,26 +83,26 @@ if (WINDOWS)
   endif (MSVC80 OR MSVC90 OR MSVC10)
   
   # Are we using the crummy Visual Studio KDU build workaround?
-  if (NOT DISABLE_FATAL_WARNINGS)
+  if (NOT VS_DISABLE_FATAL_WARNINGS)
     add_definitions(/WX)
-  endif (NOT DISABLE_FATAL_WARNINGS)
+  endif (NOT VS_DISABLE_FATAL_WARNINGS)
   
   # Various libs are compiler specific, generate some variables here we can just use
   # when we require them instead of reimplementing the test each time.
   
   if (MSVC71)
-    set(MSVC_DIR 7.1)
-    set(MSVC_SUFFIX 71)
-  elseif (MSVC80)
-    set(MSVC_DIR 8.0)
-    set(MSVC_SUFFIX 80)
-  elseif (MSVC90)
-    set(MSVC_DIR 9.0)
-    set(MSVC_SUFFIX 90)
-  elseif (MSVC10)
-    set(MSVC_DIR 10.0)
-    set(MSVC_SUFFIX 100)
-  endif (MSVC71)
+	    set(MSVC_DIR 7.1)
+	    set(MSVC_SUFFIX 71)
+    elseif (MSVC80)
+	    set(MSVC_DIR 8.0)
+	    set(MSVC_SUFFIX 80)
+    elseif (MSVC90)
+	    set(MSVC_DIR 9.0)
+	    set(MSVC_SUFFIX 90)
+    elseif (MSVC10)
+	    set(MSVC_DIR 10.0)
+	    set(MSVC_SUFFIX 100)
+    endif (MSVC71)
 
   if (MSVC10)
     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
@@ -120,149 +113,111 @@ if (WINDOWS)
     
 endif (WINDOWS)
 
-set (GCC_EXTRA_OPTIMIZATIONS "-ffast-math")
+set (GCC_EXTRA_OPTIMIZATIONS "-ffast-math -frounding-math")
 
 if (LINUX)
   set(CMAKE_SKIP_RPATH TRUE)
 
+  # Here's a giant hack for Fedora 8, where we can't use
+  # _FORTIFY_SOURCE if we're using a compiler older than gcc 4.1.
+
+  find_program(GXX g++)
+  mark_as_advanced(GXX)
+
+  if (GXX)
+    execute_process(
+        COMMAND ${GXX} --version
+        COMMAND sed "s/^[gc+ ]*//"
+        COMMAND head -1
+        OUTPUT_VARIABLE GXX_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+  else (GXX)
+    set(GXX_VERSION x)
+  endif (GXX)
+
+  # The quoting hack here is necessary in case we're using distcc or
+  # ccache as our compiler.  CMake doesn't pass the command line
+  # through the shell by default, so we end up trying to run "distcc"
+  # " g++" - notice the leading space.  Ugh.
+
+  execute_process(
+      COMMAND sh -c "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} --version"
+      COMMAND sed "s/^[gc+ ]*//"
+      COMMAND head -1
+      OUTPUT_VARIABLE CXX_VERSION
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if (${GXX_VERSION} STREQUAL ${CXX_VERSION})
+    add_definitions(-D_FORTIFY_SOURCE=2)
+  else (${GXX_VERSION} STREQUAL ${CXX_VERSION})
+    if (NOT ${GXX_VERSION} MATCHES " 4.1.*Red Hat")
+      add_definitions(-D_FORTIFY_SOURCE=2)
+    endif (NOT ${GXX_VERSION} MATCHES " 4.1.*Red Hat")
+  endif (${GXX_VERSION} STREQUAL ${CXX_VERSION})
+ 
+  #Lets actualy get a numerical version of gxx's version
+  STRING(REGEX REPLACE ".* ([0-9])\\.([0-9])\\.([0-9]).*" "\\1\\2\\3" CXX_VERSION ${CXX_VERSION})
+  
+  #gcc 4.3 and above don't like the LL boost
+  if(${CXX_VERSION} GREATER 429)
+    add_definitions(-Wno-parentheses)
+  endif (${CXX_VERSION} GREATER 429)
+
+  #gcc 4.6 has a new spammy warning
+  if(NOT ${CXX_VERSION} LESS 460)
+    add_definitions(-Wno-unused-but-set-variable)
+  endif (NOT ${CXX_VERSION} LESS 460)
+
+  # End of hacks.
+
   add_definitions(
       -DLL_LINUX=1
-      -DAPPID=secondlife
       -D_REENTRANT
       -fexceptions
       -fno-math-errno
       -fno-strict-aliasing
       -fsigned-char
-      -fvisibility=hidden
       -g
       -pthread
       )
 
-    # Don't catch SIGCHLD in our base application class for the viewer
-    # some of our 3rd party libs may need their *own* SIGCHLD handler to work.  Sigh!  
-    # The viewer doesn't need to catch SIGCHLD anyway.
-    add_definitions(-DLL_IGNORE_SIGCHLD)
-
-  if(${CMAKE_C_COMPILER} MATCHES "gcc*")
-
-    find_program(GXX g++)
-    mark_as_advanced(GXX)
-
-    if (GXX)
-      execute_process(
-          COMMAND ${GXX} --version
-          COMMAND sed "s/^[gc+ ]*//"
-          COMMAND head -1
-          OUTPUT_VARIABLE GXX_VERSION
-          OUTPUT_STRIP_TRAILING_WHITESPACE
-          )
-    else (GXX)
-      set(GXX_VERSION x)
-    endif (GXX)
-
-    # The quoting hack here is necessary in case we're using distcc or
-    # ccache as our compiler.  CMake doesn't pass the command line
-    # through the shell by default, so we end up trying to run "distcc"
-    # " g++" - notice the leading space.  Ugh.
-
-    execute_process(
-        COMMAND sh -c "${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} --version"
-        COMMAND sed "s/^[gc+ ]*//"
-        COMMAND head -1
-        OUTPUT_VARIABLE CXX_VERSION
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-    # Here's a giant hack for Fedora 8, where we can't use
-    # _FORTIFY_SOURCE if we're using a compiler older than gcc 4.1.
-    if (${GXX_VERSION} STREQUAL ${CXX_VERSION})
-      add_definitions(-D_FORTIFY_SOURCE=2)
-    else (${GXX_VERSION} STREQUAL ${CXX_VERSION})
-      if (NOT ${GXX_VERSION} MATCHES " 4.1.*Red Hat")
-        add_definitions(-D_FORTIFY_SOURCE=2)
-      endif (NOT ${GXX_VERSION} MATCHES " 4.1.*Red Hat")
-    endif (${GXX_VERSION} STREQUAL ${CXX_VERSION})
-
-    #Lets actually get a numerical version of gxx's version
-    STRING(REGEX REPLACE ".* ([0-9])\\.([0-9])\\.([0-9]).*" "\\1\\2\\3" CXX_VERSION ${CXX_VERSION})
-
-    #gcc 4.3 and above doesn't like the LL boost
-    if(${CXX_VERSION} GREATER 429)
-      add_definitions(-Wno-parentheses)
-    endif (${CXX_VERSION} GREATER 429)
-
-    #gcc 4.6 has a new spammy warning
-    if(NOT ${CXX_VERSION} LESS 460)
-      add_definitions(-Wno-unused-but-set-variable)
-    endif (NOT ${CXX_VERSION} LESS 460)
-
-    # End of hacks.
-
-    #GCC Specific
-    add_definitions(-DCC_GCC)
-
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
-
+  add_definitions(-DAPPID=secondlife)
+  add_definitions(-fvisibility=hidden)
+  # don't catch SIGCHLD in our base application class for the viewer - some of our 3rd party libs may need their *own* SIGCHLD handler to work.  Sigh!  The viewer doesn't need to catch SIGCHLD anyway.
+  add_definitions(-DLL_IGNORE_SIGCHLD)
+  if (NOT STANDALONE)
+    # this stops us requiring a really recent glibc at runtime
+    add_definitions(-fno-stack-protector)
+  endif (NOT STANDALONE)
+  if (${ARCH} STREQUAL "x86_64")
+    add_definitions(-DLINUX64=1 -pipe)
+    set(CMAKE_CXX_FLAGS_RELEASESSE2 "${CMAKE_CXX_FLAGS_RELEASESSE2} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+    set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
+  else (${ARCH} STREQUAL "x86_64")
     if (NOT STANDALONE)
-      # this stops us requiring a really recent glibc at runtime
-      add_definitions(-fno-stack-protector)
+  	set(MARCH_FLAG " -march=pentium4")
     endif (NOT STANDALONE)
-    if (${ARCH} STREQUAL "x86_64")
-      add_definitions(-DLINUX64=1 -pipe)
-      set(CMAKE_CXX_FLAGS_RELEASESSE2 "${CMAKE_CXX_FLAGS_RELEASESSE2} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
-      set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
-      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
-      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -fomit-frame-pointer -mmmx -msse -mfpmath=sse -msse2 -ffast-math -ftree-vectorize -fweb -fexpensive-optimizations -frename-registers")
-    else (${ARCH} STREQUAL "x86_64")
-      if (NOT STANDALONE)
-        set(MARCH_FLAG " -march=pentium4")
-      endif (NOT STANDALONE)
-      set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}${MARCH_FLAG} -fno-inline -msse2")
-      set(CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}${MARCH_FLAG} -fno-inline -msse2")
-      set(CMAKE_CXX_FLAGS_RELEASESSE2 "${CMAKE_CXX_FLAGS_RELEASESSE2}${MARCH_FLAG} -mfpmath=sse,387 -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
-      set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2}${MARCH_FLAG} -mfpmath=sse,387 -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
-      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}${MARCH_FLAG} -mfpmath=sse,387 -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
-      set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}${MARCH_FLAG} -mfpmath=sse,387 -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
-    endif (${ARCH} STREQUAL "x86_64")
-  elseif(${CMAKE_C_COMPILER} MATCHES "clang*")
- 
-    find_program(CLANG clang++)
-    mark_as_advanced(CLANG)
+    set(CMAKE_CXX_FLAGS_RELEASESSE2 "${CMAKE_CXX_FLAGS_RELEASESSE2}${MARCH_FLAG} -mfpmath=sse -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
+    set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2}${MARCH_FLAG} -mfpmath=sse -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}${MARCH_FLAG} -mfpmath=sse -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}${MARCH_FLAG} -mfpmath=sse -msse2 ${GCC_EXTRA_OPTIMIZATIONS}")
+  endif (${ARCH} STREQUAL "x86_64")
 
-    add_definitions(
-        -DCC_CLANG
-        -D_FORTIFY_SOURCE=2
-        )
-
-    if (NOT STANDALONE)
-      # this stops us requiring a really recent glibc at runtime
-      add_definitions(-fno-stack-protector)
-    endif (NOT STANDALONE)
-
-    if (NOT STANDALONE)
-      set(MARCH_FLAG " -march=pentium4")
-    endif (NOT STANDALONE)
-
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}${MARCH_FLAG} -fno-inline -msse2")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}${MARCH_FLAG} -fno-inline -msse2")
-    set(CMAKE_CXX_FLAGS_RELEASESSE2 "${CMAKE_CXX_FLAGS_RELEASESSE2}${MARCH_FLAG} -msse2")
-    set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2}${MARCH_FLAG} -msse2")
-    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}${MARCH_FLAG} -msse2")
-    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}${MARCH_FLAG} -msse2")
-  endif()
-
-  set(CMAKE_CXX_FLAGS_DEBUG "-O0 ${CMAKE_CXX_FLAGS_DEBUG}")
-  set(CMAKE_C_FLAGS_DEBUG "-O0 ${CMAKE_CXX_FLAGS_DEBUG}")
+  set(CMAKE_CXX_FLAGS_DEBUG "-fno-inline ${CMAKE_CXX_FLAGS_DEBUG} -msse2")
   set(CMAKE_CXX_FLAGS_RELEASE "-O3 ${CMAKE_CXX_FLAGS_RELEASE}")
   set(CMAKE_C_FLAGS_RELEASE "-O3 ${CMAKE_C_FLAGS_RELEASE}")
   set(CMAKE_CXX_FLAGS_RELEASESSE2 "-O3 ${CMAKE_CXX_FLAGS_RELEASESSE2}")
   set(CMAKE_C_FLAGS_RELEASESSE2 "-O3 ${CMAKE_C_FLAGS_RELEASESSE2}")
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O3 ${CMAKE_C_FLAGS_RELWITHDEBINFO}")  
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O3 ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
 endif (LINUX)
 
 
 if (DARWIN)
-  add_definitions(-DLL_DARWIN=1 -D_XOPEN_SOURCE)
+  add_definitions(-DLL_DARWIN=1)
   set(CMAKE_CXX_LINK_FLAGS "-Wl,-headerpad_max_install_names,-search_paths_first")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_CXX_LINK_FLAGS}")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mlong-branch")
@@ -270,30 +225,26 @@ if (DARWIN)
   # NOTE: it's critical that the optimization flag is put in front.
   # NOTE: it's critical to have both CXX_FLAGS and C_FLAGS covered.
   set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
-  set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -03 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
   set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
-  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O3 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -03 -msse3 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
   set(CMAKE_CXX_FLAGS_RELEASESSE2 "${CMAKE_CXX_FLAGS_RELEASESSE2} -O3 -msse2 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
-  set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2} -O3 -msse2 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
+  set(CMAKE_C_FLAGS_RELEASESSE2 "${CMAKE_C_FLAGS_RELEASESSE2} -03 -msse2 -mtune=generic -mfpmath=sse ${GCC_EXTRA_OPTIMIZATIONS}")
 endif (DARWIN)
 
 
 if (LINUX OR DARWIN)
-  if(${CMAKE_C_COMPILER} MATCHES "gcc*")
-    set(UNIX_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs")
-    set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS} -Wno-reorder -Wno-non-virtual-dtor -Woverloaded-virtual")
-  elseif(${CMAKE_C_COMPILER} MATCHES "clang*")
-    set(UNIX_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs -Wno-tautological-compare -Wno-char-subscripts -Wno-gnu -Wno-logical-op-parentheses 
-    -Wno-non-virtual-dtor -Woverloaded-virtual -Wno-parentheses-equality -Wno-reorder -Wno-unused-function -Wno-unused-value -Wno-unused-variable")
-    set(UNIX_CXX_WARNINGS "${UNIX_WARNINGS}")
-  endif()
-  
-  if (NOT DISABLE_FATAL_WARNINGS)
-    set(UNIX_WARNINGS "${UNIX_WARNINGS} -Werror")
-  endif (NOT DISABLE_FATAL_WARNINGS)
+  set(GCC_WARNINGS "-Wall -Wno-sign-compare -Wno-trigraphs")
+
+  if (NOT GCC_DISABLE_FATAL_WARNINGS)
+    set(GCC_WARNINGS "${GCC_WARNINGS} -Werror")
+  endif (NOT GCC_DISABLE_FATAL_WARNINGS)
+
+  set(GCC_CXX_WARNINGS "${GCC_WARNINGS} -Wno-reorder -Wno-non-virtual-dtor -Woverloaded-virtual")
+
+  set(CMAKE_C_FLAGS "${GCC_WARNINGS} ${CMAKE_C_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${GCC_CXX_WARNINGS} ${CMAKE_CXX_FLAGS}")
 
-  set(CMAKE_C_FLAGS "${UNIX_WARNINGS} ${CMAKE_C_FLAGS}")
-  set(CMAKE_CXX_FLAGS "${UNIX_CXX_WARNINGS} ${CMAKE_CXX_FLAGS}")
   if (WORD_SIZE EQUAL 32)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m32")
@@ -319,12 +270,8 @@ else (STANDALONE)
 endif (STANDALONE)
 
 if(1 EQUAL 1)
-  add_definitions(-DOPENSIM_RULES=1)
-  add_definitions(-DMESH_ENABLED=1)
-  add_definitions(-DENABLE_CLASSIC_CLOUDS=1)
-  if (NOT "$ENV{SHY_MOD}" STREQUAL "")
-    add_definitions(-DSHY_MOD=1)
-  endif (NOT "$ENV{SHY_MOD}" STREQUAL "")
+	add_definitions(-DOPENSIM_RULES=1)
+	add_definitions(-DMESH_ENABLED=1)
 endif(1 EQUAL 1)
 
 SET( CMAKE_EXE_LINKER_FLAGS_RELEASESSE2

indra/cmake/APR.cmake

@@ -29,12 +29,12 @@ else (STANDALONE)
       )
   elseif (DARWIN)
     set(APR_LIBRARIES 
-      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libapr-1.0.dylib
-      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libapr-1.0.dylib
+      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libapr-1.0.3.7.dylib
+      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libapr-1.0.3.7.dylib
       )
     set(APRUTIL_LIBRARIES 
-      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libaprutil-1.0.dylib
-      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libaprutil-1.0.dylib
+      debug ${ARCH_PREBUILT_DIRS_DEBUG}/libaprutil-1.0.3.8.dylib
+      optimized ${ARCH_PREBUILT_DIRS_RELEASE}/libaprutil-1.0.3.8.dylib
       )
     set(APRICONV_LIBRARIES iconv)
   else (WINDOWS)

indra/cmake/Boost.cmake

@@ -10,7 +10,7 @@ if (STANDALONE)
   set(BOOST_FILESYSTEM_LIBRARY boost_filesystem-mt)
   set(BOOST_PROGRAM_OPTIONS_LIBRARY boost_program_options-mt)
   set(BOOST_REGEX_LIBRARY boost_regex-mt)
-  set(BOOST_SYSTEM_LIBRARY boost_system-mt)
+  set(BOOST_SYSTEM_LIBRARY boost_system-mt)  
 else (STANDALONE)
   use_prebuilt_binary(boost)
   set(Boost_INCLUDE_DIRS ${LIBS_PREBUILT_DIR}/include)

indra/cmake/BuildVersion.cmake

@@ -1,45 +1,23 @@
 # -*- cmake -*-
 
-# Read version components from the header file.
-file(STRINGS ${LIBS_OPEN_DIR}/llcommon/llversionviewer.h.in lines
-   REGEX " LL_VERSION_")
-foreach(line ${lines})
-  string(REGEX REPLACE ".*LL_VERSION_([A-Z]+).*" "\\1" comp "${line}")
-  string(REGEX REPLACE ".* = ([0-9]+);.*" "\\1" value "${line}")
-  set(v${comp} "${value}")
-endforeach(line)
+function (build_version _target)
+  # Read version components from the header file.
+  file(STRINGS ${LIBS_OPEN_DIR}/llcommon/llversion${_target}.h lines
+       REGEX " LL_VERSION_")
+  foreach(line ${lines})
+    string(REGEX REPLACE ".*LL_VERSION_([A-Z]+).*" "\\1" comp "${line}")
+    string(REGEX REPLACE ".* = ([0-9]+);.*" "\\1" value "${line}")
+    set(v${comp} "${value}")
+  endforeach(line)
 
-execute_process(
-    COMMAND git rev-list HEAD
-    OUTPUT_VARIABLE GIT_REV_LIST_STR
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-)
+  # Compose the version.
+  set(${_target}_VERSION "${vMAJOR}.${vMINOR}.${vPATCH}.${vBUILD}")
+  if (${_target}_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")
+    message(STATUS "Version of ${_target} is ${${_target}_VERSION}")
+  else (${_target}_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")
+    message(FATAL_ERROR "Could not determine ${_target} version (${${_target}_VERSION})")
+  endif (${_target}_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")
 
-if(GIT_REV_LIST_STR)
-  string(REPLACE "\n" ";" GIT_REV_LIST ${GIT_REV_LIST_STR})
-else()
-  string(REPLACE "\n" ";" GIT_REV_LIST "")
-endif()
-
-if(GIT_REV_LIST)
-  list(LENGTH GIT_REV_LIST vBUILD)
-else()
-  set(vBUILD 99)
-endif()
-
-configure_file(
-    ${CMAKE_SOURCE_DIR}/llcommon/llversionviewer.h.in
-    ${CMAKE_SOURCE_DIR}/llcommon/llversionviewer.h
-)
-
-# Compose the version.
-set(viewer_VERSION "${vMAJOR}.${vMINOR}.${vPATCH}.${vBUILD}")
-if (viewer_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")
-  message(STATUS "Version is ${viewer_VERSION}")
-else (viewer_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")
-  message(FATAL_ERROR "Could not determine version (${viewer_VERSION})")
-endif (viewer_VERSION MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+$")
-
-# Report version to caller.
-#set(viewer_VERSION "${viewer_VERSION}" PARENT_SCOPE)
+  # Report version to caller.
+  set(${_target}_VERSION "${${_target}_VERSION}" PARENT_SCOPE)
+endfunction (build_version)

indra/cmake/CARes.cmake

@@ -10,7 +10,6 @@ if (STANDALONE)
 else (STANDALONE)
     use_prebuilt_binary(ares)
     if (WINDOWS)
-        add_definitions("-DCARES_STATICLIB")
         set(CARES_LIBRARIES areslib)
     elseif (DARWIN)
         set(CARES_LIBRARIES

indra/cmake/CMakeLists.txt

@@ -79,6 +79,7 @@ set(cmake_SOURCE_FILES
     UI.cmake
     UnixInstall.cmake
     Variables.cmake
+    Versions.cmake
     XmlRpcEpi.cmake
     ZLIB.cmake
     )

indra/cmake/DirectX.cmake

@@ -3,7 +3,7 @@
 if (VIEWER AND WINDOWS)
   find_path(DIRECTX_INCLUDE_DIR dxdiag.h
             "$ENV{DXSDK_DIR}/Include"
-            "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (June 2010)/Include"
+			"$ENV{PROGRAMFILES}/Microsoft DirectX SDK (June 2010)/Include"
             "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (March 2009)/Include"
             "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (August 2008)/Include"
             "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (June 2008)/Include"
@@ -25,7 +25,7 @@ if (VIEWER AND WINDOWS)
 
   find_path(DIRECTX_LIBRARY_DIR dxguid.lib
             "$ENV{DXSDK_DIR}/Lib/x86"
-            "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (June 2010)/Lib/x86"
+			"$ENV{PROGRAMFILES}/Microsoft DirectX SDK (June 2010)/Lib/x86"
             "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (March 2009)/Lib/x86"
             "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (August 2008)/Lib/x86"
             "$ENV{PROGRAMFILES}/Microsoft DirectX SDK (June 2008)/Lib/x86"

indra/cmake/FMOD.cmake

@@ -7,13 +7,26 @@ if(INSTALL_PROPRIETARY)
   use_prebuilt_binary(fmod)
 endif(INSTALL_PROPRIETARY)
 
-find_library(FMOD_LIBRARY
+find_library(FMOD_LIBRARY_RELEASE
              NAMES fmod fmodvc fmod-3.75
              PATHS
-             optimized ${ARCH_PREBUILT_DIRS_RELEASE}
-             debug ${ARCH_PREBUILT_DIRS_DEBUG}
+             ${ARCH_PREBUILT_DIRS_RELEASE}
              )
 
+find_library(FMOD_LIBRARY_DEBUG
+             NAMES fmod fmodvc fmod-3.75
+             PATHS
+             ${ARCH_PREBUILT_DIRS_DEBUG}
+             )
+
+if (FMOD_LIBRARY_RELEASE AND FMOD_LIBRARY_DEBUG)
+  set(FMOD_LIBRARY
+      debug ${FMOD_LIBRARY_DEBUG}
+      optimized ${FMOD_LIBRARY_RELEASE})
+elseif (FMOD_LIBRARY_RELEASE)
+  set(FMOD_LIBRARY ${FMOD_LIBRARY_RELEASE})
+endif (FMOD_LIBRARY_RELEASE AND FMOD_LIBRARY_DEBUG)
+
 if (NOT FMOD_LIBRARY)
   set(FMOD_SDK_DIR CACHE PATH "Path to the FMOD SDK.")
   if (FMOD_SDK_DIR)

indra/cmake/FMODEX.cmake

@@ -7,13 +7,26 @@ if(INSTALL_PROPRIETARY)
   use_prebuilt_binary(fmodex)
 endif(INSTALL_PROPRIETARY)
 
-find_library(FMODEX_LIBRARY
+find_library(FMODEX_LIBRARY_RELEASE
              NAMES fmodex fmodex_vc fmodexL_vc
              PATHS
-             optimized ${ARCH_PREBUILT_DIRS_RELEASE}
-             debug ${ARCH_PREBUILT_DIRS_DEBUG}
+             ${ARCH_PREBUILT_DIRS_RELEASE}
              )
 
+find_library(FMODEX_LIBRARY_DEBUG
+             NAMES fmodex fmodex_vc fmodexL_vc
+             PATHS
+             ${ARCH_PREBUILT_DIRS_DEBUG}
+             )
+
+if (FMODEX_LIBRARY_RELEASE AND FMODEX_LIBRARY_DEBUG)
+  set(FMODEX_LIBRARY
+      debug ${FMODEX_LIBRARY_DEBUG}
+      optimized ${FMODEX_LIBRARY_RELEASE})
+elseif (FMODEX_LIBRARY_RELEASE)
+  set(FMODEX_LIBRARY ${FMODEX_LIBRARY_RELEASE})
+endif (FMODEX_LIBRARY_RELEASE AND FMODEX_LIBRARY_DEBUG)
+
 if (NOT FMODEX_LIBRARY)
   set(FMODEX_SDK_DIR CACHE PATH "Path to the FMOD Ex SDK.")
   if (FMODEX_SDK_DIR)

indra/cmake/FindJsonCpp.cmake

@@ -9,7 +9,7 @@
 #  also defined, but not for general use are
 #  JSONCPP_LIBRARY, where to find the jsoncpp library.
 
-FIND_PATH(JSONCPP_INCLUDE_DIR json/json.h
+FIND_PATH(JSONCPP_INCLUDE_DIR jsoncpp/json.h
 /usr/local/include
 /usr/include
 )

indra/cmake/LLCommon.cmake

@@ -14,7 +14,6 @@ endif (DARWIN)
 set(LLCOMMON_INCLUDE_DIRS
     ${LIBS_OPEN_DIR}/cwdebug
     ${LIBS_OPEN_DIR}/llcommon
-    ${APRUTIL_INCLUDE_DIR}
     ${APR_INCLUDE_DIR}
     ${Boost_INCLUDE_DIRS}
     )

indra/cmake/LLPlugin.cmake

@@ -8,7 +8,7 @@ set(LLPLUGIN_INCLUDE_DIRS
 if (LINUX)
     # In order to support using ld.gold on linux, we need to explicitely
     # specify all libraries that llplugin uses.
-    set(LLPLUGIN_LIBRARIES llplugin pthread)
+	set(LLPLUGIN_LIBRARIES llplugin pthread)
 else (LINUX)
-    set(LLPLUGIN_LIBRARIES llplugin)
+	set(LLPLUGIN_LIBRARIES llplugin)
 endif (LINUX)

indra/cmake/LLXUIXML.cmake

@@ -1,7 +0,0 @@
-# -*- cmake -*-
-
-set(LLXUIXML_INCLUDE_DIRS
-    ${LIBS_OPEN_DIR}/llxuixml
-    )
-
-set(LLXUIXML_LIBRARIES llxuixml)

indra/cmake/Python.cmake

@@ -19,6 +19,7 @@ if (WINDOWS)
     [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\2.5\\InstallPath]
     [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\2.4\\InstallPath]
     [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\2.3\\InstallPath]
+
     )
 elseif (EXISTS /etc/debian_version)
   # On Debian and Ubuntu, avoid Python 2.4 if possible.

indra/cmake/UI.cmake

@@ -38,7 +38,6 @@ else (STANDALONE)
   if (LINUX)
     set(UI_LIBRARIES
         atk-1.0
-        X11
         gdk-x11-2.0
         gdk_pixbuf-2.0
         Xinerama

indra/cmake/Versions.cmake

@@ -0,0 +1,9 @@
+include(BuildVersion)
+
+if(VIEWER)
+  build_version(viewer)
+endif(VIEWER)
+
+if(SERVER)
+  build_version(server)
+endif(SERVER)

indra/cmake/WebKitLibPlugin.cmake

@@ -67,16 +67,11 @@ elseif (LINUX)
         QtNetwork
         QtGui
         QtCore
-        crypto
-        ssl
-#       qgif
-#       qjpeg
         jscore
         jpeg
         fontconfig
         X11
         Xrender
-        Xext
         GL
         )
      endif (STANDALONE)

indra/cwdebug/debug.cc

@@ -171,8 +171,7 @@ void stop_recording_backtraces(void)
       channel_ct gtk DDCN("GTK");		//!< This debug channel is used for output related to gtk.
       channel_ct sdl DDCN("SDL");		//!< This debug channel is used for output related to sdl locking.
       channel_ct backtrace DDCN("BACKTRACE");	//!< This debug channel is used for backtraces.
-      channel_ct statemachine DDCN("STATEMACHINE");	//!< This debug channel is used for output related to class AIStateMachine.
-      channel_ct caps DDCN("CAPS");		//!< This debug channel is used for output related to Capabilities.
+      channel_ct statemachine DDCN("STATEMACHINE");	//!< This debug channel is used class AIStateMachine.
 
     } // namespace dc
   } // namespace DEBUGCHANNELS

indra/cwdebug/debug.h

@@ -117,7 +117,6 @@ extern CWD_API channel_ct gtk;
 extern CWD_API channel_ct sdl;
 extern CWD_API channel_ct backtrace;
 extern CWD_API channel_ct statemachine;
-extern CWD_API channel_ct caps;
 
 #endif
 

indra/develop.py

@@ -775,8 +775,9 @@ Options:
   -p | --project=NAME   set the root project name. (Doesn't effect makefiles)
                         
 Commands:
-  build           configure and build default target
-  clean           delete all build directories, does not affect sources
+  build      configure and build default target
+  clean      delete all build directories, does not affect sources
+  configure  configure project by running cmake (default command if none given)
   configure       configure project by running cmake (default if none given)
   printbuilddirs  print the build directory that will be used
 

indra/lib/python/indra/util/llmanifest.py

@@ -168,10 +168,7 @@ ARGUMENTS=[
     dict(name='version',
          description="""This specifies the version of Second Life that is
         being packaged up.""",
-         default=get_default_version),
-    dict(name='extra_libraries',
-         description="""List of extra libraries to include in package""",
-         default=None)
+         default=get_default_version)
     ]
 
 def usage(srctree=""):

indra/libopenjpeg/dwt.c

@@ -570,7 +570,7 @@ static void v4dwt_interleave_h(v4dwt_t* restrict w, float* restrict a, int x, in
 	int count = w->sn;
 	int i, k;
 	for(k = 0; k < 2; ++k){
-		if (count + 3 * x < size && ((long) a & 0x0f) == 0 && ((long) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
+		if (count + 3 * x < size && ((int) a & 0x0f) == 0 && ((int) bi & 0x0f) == 0 && (x & 0x0f) == 0) {
 			/* Fast code path */
 			for(i = 0; i < count; ++i){
 				int j = i;

indra/libopenjpeg/opj_malloc.h

@@ -1,163 +1,163 @@
-/*
- * Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
- * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef __OPJ_MALLOC_H
-#define __OPJ_MALLOC_H
-/**
-@file opj_malloc.h
-@brief Internal functions
-
-The functions in opj_malloc.h are internal utilities used for memory management.
-*/
-
-/** @defgroup MISC MISC - Miscellaneous internal functions */
-/*@{*/
-
-/** @name Exported functions */
-/*@{*/
-/* ----------------------------------------------------------------------- */
-
-/**
-Allocate an uninitialized memory block
-@param size Bytes to allocate
-@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
-*/
-#ifdef ALLOC_PERF_OPT
-void * OPJ_CALLCONV opj_malloc(size_t size);
-#else
-#define opj_malloc(size) malloc(size)
-#endif
-
-/**
-Allocate a memory block with elements initialized to 0
-@param num Blocks to allocate
-@param size Bytes per block to allocate
-@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
-*/
-#ifdef ALLOC_PERF_OPT
-void * OPJ_CALLCONV opj_calloc(size_t _NumOfElements, size_t _SizeOfElements);
-#else
-#define opj_calloc(num, size) calloc(num, size)
-#endif
-
-/**
-Allocate memory aligned to a 16 byte boundry
-@param size Bytes to allocate
-@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
-*/
-/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
-#ifdef WIN32
-	/* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */
-	#ifdef __GNUC__
-		#include <mm_malloc.h>
-		#define HAVE_MM_MALLOC
-	#else /* MSVC, Intel C++ */
-		#include <malloc.h>
-		#ifdef _mm_malloc
-			#define HAVE_MM_MALLOC
-		#endif
-	#endif
-#else /* Not WIN32 */
-	#if defined(__sun)
-		#define HAVE_MEMALIGN
-	/* Linux x86_64 and OSX always align allocations to 16 bytes */
-	#elif !defined(__amd64__) && !defined(__APPLE__)	
-		#define HAVE_MEMALIGN
-		#include <malloc.h>			
-	#endif
-#endif
-
-#define opj_aligned_malloc(size) malloc(size)
-#define opj_aligned_free(m) free(m)
-
-#ifdef HAVE_MM_MALLOC
-	#undef opj_aligned_malloc
-	#define opj_aligned_malloc(size) _mm_malloc(size, 16)
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) _mm_free(m)
-#endif
-
-#ifdef HAVE_MEMALIGN
-	extern void* memalign(size_t, size_t);
-	#undef opj_aligned_malloc
-	#define opj_aligned_malloc(size) memalign(16, (size))
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) free(m)
-#endif
-
-#ifdef HAVE_POSIX_MEMALIGN
-	#undef opj_aligned_malloc
-	extern int posix_memalign(void**, size_t, size_t);
-
-	static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){
-		void* mem = NULL;
-		posix_memalign(&mem, 16, size);
-		return mem;
-	}
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) free(m)
-#endif
-
-#ifdef ALLOC_PERF_OPT
-	#undef opj_aligned_malloc
-	#define opj_aligned_malloc(size) opj_malloc(size)
-	#undef opj_aligned_free
-	#define opj_aligned_free(m) opj_free(m)
-#endif
-
-/**
-Reallocate memory blocks.
-@param memblock Pointer to previously allocated memory block
-@param size New size in bytes
-@return Returns a void pointer to the reallocated (and possibly moved) memory block
-*/
-#ifdef ALLOC_PERF_OPT
-void * OPJ_CALLCONV opj_realloc(void * _Memory, size_t NewSize);
-#else
-#define opj_realloc(m, s) realloc(m, s)
-#endif
-
-/**
-Deallocates or frees a memory block.
-@param memblock Previously allocated memory block to be freed
-*/
-#ifdef ALLOC_PERF_OPT
-void OPJ_CALLCONV opj_free(void * _Memory);
-#else
-#define opj_free(m) free(m)
-#endif
-
-#ifdef __GNUC__
-#pragma GCC poison malloc calloc realloc free
-#endif
-
-/* ----------------------------------------------------------------------- */
-/*@}*/
-
-/*@}*/
-
-#endif /* __OPJ_MALLOC_H */
-
+/*
+ * Copyright (c) 2005, Herv<72> Drolon, FreeImage Team
+ * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __OPJ_MALLOC_H
+#define __OPJ_MALLOC_H
+/**
+@file opj_malloc.h
+@brief Internal functions
+
+The functions in opj_malloc.h are internal utilities used for memory management.
+*/
+
+/** @defgroup MISC MISC - Miscellaneous internal functions */
+/*@{*/
+
+/** @name Exported functions */
+/*@{*/
+/* ----------------------------------------------------------------------- */
+
+/**
+Allocate an uninitialized memory block
+@param size Bytes to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+#ifdef ALLOC_PERF_OPT
+void * OPJ_CALLCONV opj_malloc(size_t size);
+#else
+#define opj_malloc(size) malloc(size)
+#endif
+
+/**
+Allocate a memory block with elements initialized to 0
+@param num Blocks to allocate
+@param size Bytes per block to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+#ifdef ALLOC_PERF_OPT
+void * OPJ_CALLCONV opj_calloc(size_t _NumOfElements, size_t _SizeOfElements);
+#else
+#define opj_calloc(num, size) calloc(num, size)
+#endif
+
+/**
+Allocate memory aligned to a 16 byte boundry
+@param size Bytes to allocate
+@return Returns a void pointer to the allocated space, or NULL if there is insufficient memory available
+*/
+/* FIXME: These should be set with cmake tests, but we're currently not requiring use of cmake */
+#ifdef WIN32
+	/* Someone should tell the mingw people that their malloc.h ought to provide _mm_malloc() */
+	#ifdef __GNUC__
+		#include <mm_malloc.h>
+		#define HAVE_MM_MALLOC
+	#else /* MSVC, Intel C++ */
+		#include <malloc.h>
+		#ifdef _mm_malloc
+			#define HAVE_MM_MALLOC
+		#endif
+	#endif
+#else /* Not WIN32 */
+	#if defined(__sun)
+		#define HAVE_MEMALIGN
+	/* Linux x86_64 and OSX always align allocations to 16 bytes */
+	#elif !defined(__amd64__) && !defined(__APPLE__)	
+		#define HAVE_MEMALIGN
+		#include <malloc.h>			
+	#endif
+#endif
+
+#define opj_aligned_malloc(size) malloc(size)
+#define opj_aligned_free(m) free(m)
+
+#ifdef HAVE_MM_MALLOC
+	#undef opj_aligned_malloc
+	#define opj_aligned_malloc(size) _mm_malloc(size, 16)
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) _mm_free(m)
+#endif
+
+#ifdef HAVE_MEMALIGN
+	extern void* memalign(size_t, size_t);
+	#undef opj_aligned_malloc
+	#define opj_aligned_malloc(size) memalign(16, (size))
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) free(m)
+#endif
+
+#ifdef HAVE_POSIX_MEMALIGN
+	#undef opj_aligned_malloc
+	extern int posix_memalign(void**, size_t, size_t);
+
+	static INLINE void* __attribute__ ((malloc)) opj_aligned_malloc(size_t size){
+		void* mem = NULL;
+		posix_memalign(&mem, 16, size);
+		return mem;
+	}
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) free(m)
+#endif
+
+#ifdef ALLOC_PERF_OPT
+	#undef opj_aligned_malloc
+	#define opj_aligned_malloc(size) opj_malloc(size)
+	#undef opj_aligned_free
+	#define opj_aligned_free(m) opj_free(m)
+#endif
+
+/**
+Reallocate memory blocks.
+@param memblock Pointer to previously allocated memory block
+@param size New size in bytes
+@return Returns a void pointer to the reallocated (and possibly moved) memory block
+*/
+#ifdef ALLOC_PERF_OPT
+void * OPJ_CALLCONV opj_realloc(void * _Memory, size_t NewSize);
+#else
+#define opj_realloc(m, s) realloc(m, s)
+#endif
+
+/**
+Deallocates or frees a memory block.
+@param memblock Previously allocated memory block to be freed
+*/
+#ifdef ALLOC_PERF_OPT
+void OPJ_CALLCONV opj_free(void * _Memory);
+#else
+#define opj_free(m) free(m)
+#endif
+
+#ifdef __GNUC__
+#pragma GCC poison malloc calloc realloc free
+#endif
+
+/* ----------------------------------------------------------------------- */
+/*@}*/
+
+/*@}*/
+
+#endif /* __OPJ_MALLOC_H */
+

indra/llaudio/CMakeLists.txt

@@ -5,25 +5,27 @@ project(llaudio)
 include(00-Common)
 include(Audio)
 include(LLAudio)
-if (FMODEX)
-  include(FMODEX)
-  set(FMOD OFF)
-endif (FMODEX)
-if (NOT FMODEX)
-  include(FMOD)
-endif (NOT FMODEX)
+if(FMODEX)
+	include(FMODEX)
+	if(FMODEX)
+		set(FMOD OFF)
+	endif(FMODEX)
+endif(FMODEX)
+if(NOT FMODEX)
+	include(FMOD)
+endif(NOT FMODEX)
 include(OPENAL)
 include(LLCommon)
 include(LLMath)
 include(LLMessage)
 include(LLVFS)
 
-if (FMODEX)
-  include_directories(${FMODEX_INCLUDE_DIR})
+if(FMODEX)
+	include_directories(${FMODEX_INCLUDE_DIR})
 endif(FMODEX)
 if(FMOD)
-  include_directories(${FMOD_INCLUDE_DIR})
-endif (FMOD)
+	include_directories(${FMOD_INCLUDE_DIR})
+endif(FMOD)
 
 include_directories(
     ${LLAUDIO_INCLUDE_DIRS}

indra/llaudio/llaudiodecodemgr.cpp

@@ -168,13 +168,19 @@ long vfs_tell (void *datasource)
 	return file->tell();
 }
 
-LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &out_filename) :
-	mValid(FALSE), mDone(FALSE), mBytesRead(-1), mUUID(uuid),
-#if !defined(USE_WAV_VFILE)
-	mOutFilename(out_filename), mFileHandle(LLLFSThread::nullHandle()),
-#endif
-	mInFilep(NULL), mCurrentSection(0)
+LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &out_filename)
 {
+	mDone = FALSE;
+	mValid = FALSE;
+	mBytesRead = -1;
+	mUUID = uuid;
+	mInFilep = NULL;
+	mCurrentSection = 0;
+#if !defined(USE_WAV_VFILE)
+	mOutFilename = out_filename;
+	mFileHandle = LLLFSThread::nullHandle();
+#endif
+	// No default value for mVF, it's an ogg structure?
 }
 
 LLVorbisDecodeState::~LLVorbisDecodeState()
@@ -236,8 +242,8 @@ BOOL LLVorbisDecodeState::initDecode()
 		llwarns << "No default bitstream found" << llendl;	
 	}
 	// <edit>
-	// This magic value is equivalent to 150MiB of data.
-	// Prevents griefers from utilizing a huge xbox sound the size of god to instafry the viewer
+		// This magic value is equivilent to 150MiB of data.
+		// Prevents griffers from utilizin a huge xbox sound the size of god to instafry the viewer
 	if(size_guess >= 157286400)
 	{
 		llwarns << "Bad sound caught by zmagic" << llendl;
@@ -610,8 +616,7 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 				llwarns << mCurrentDecodep->getUUID() << " has invalid vorbis data, aborting decode" << llendl;
 				mCurrentDecodep->flushBadFile();
 				LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
-				adp->setHasValidData(false);
-				adp->setHasCompletedDecode(true);
+				adp->setHasValidData(FALSE);
 				mCurrentDecodep = NULL;
 				done = TRUE;
 			}
@@ -626,16 +631,11 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 				if (mCurrentDecodep->finishDecode())
 				{
 					// We finished!
-					LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
-					if (!adp)
+					if (mCurrentDecodep->isValid() && mCurrentDecodep->isDone())
 					{
-						llwarns << "Missing LLAudioData for decode of " << mCurrentDecodep->getUUID() << llendl;
-					}
-					else if (mCurrentDecodep->isValid() && mCurrentDecodep->isDone())
-					{
-						adp->setHasCompletedDecode(true);
-						adp->setHasDecodedData(true);
-						adp->setHasValidData(true);
+						LLAudioData *adp = gAudiop->getAudioData(mCurrentDecodep->getUUID());
+						adp->setHasDecodedData(TRUE);
+						adp->setHasValidData(TRUE);
 
 						// At this point, we could see if anyone needs this sound immediately, but
 						// I'm not sure that there's a reason to - we need to poll all of the playing
@@ -644,8 +644,7 @@ void LLAudioDecodeMgr::Impl::processQueue(const F32 num_secs)
 					}
 					else
 					{
-						adp->setHasCompletedDecode(true);
-						llinfos << "Vorbis decode failed for " << mCurrentDecodep->getUUID() << llendl;
+						llinfos << "Vorbis decode failed!!!" << llendl;
 					}
 					mCurrentDecodep = NULL;
 				}
@@ -713,18 +712,15 @@ BOOL LLAudioDecodeMgr::addDecodeRequest(const LLUUID &uuid)
 	if (gAudiop->hasDecodedFile(uuid))
 	{
 		// Already have a decoded version, don't need to decode it.
-		//llinfos << "addDecodeRequest for " << uuid << " has decoded file already" << llendl;
 		return TRUE;
 	}
 
 	if (gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
 	{
 		// Just put it on the decode queue.
-		//llinfos << "addDecodeRequest for " << uuid << " has local asset file already" << llendl;
 		mImpl->mDecodeQueue.push(uuid);
 		return TRUE;
 	}
 
-	//llinfos << "addDecodeRequest for " << uuid << " no file available" << llendl;
 	return FALSE;
 }

indra/llaudio/llaudioengine.cpp

@@ -1275,11 +1275,10 @@ void LLAudioEngine::assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::E
 		// Need to mark data as bad to avoid constant rerequests.
 		LLAudioData *adp = gAudiop->getAudioData(uuid);
 		if (adp)
-		{	// Make sure everything is cleared
+        {
 			adp->setHasValidData(false);
 			adp->setHasLocalData(false);
 			adp->setHasDecodedData(false);
-			adp->setHasCompletedDecode(true);
 		}
 	}
 	else
@@ -1292,10 +1291,9 @@ void LLAudioEngine::assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::E
         }
 		else
 		{
-			// llinfos << "Got asset callback with good audio data for " << uuid << ", making decode request" << llendl;
 			adp->setHasValidData(true);
-			adp->setHasLocalData(true);
-			gAudioDecodeMgrp->addDecodeRequest(uuid);
+		    adp->setHasLocalData(true);
+		    gAudioDecodeMgrp->addDecodeRequest(uuid);
 		}
 	}
 	gAudiop->mCurrentTransfer = LLUUID::null;
@@ -1323,7 +1321,6 @@ LLAudioSource::LLAudioSource(const LLUUID& id, const LLUUID& owner_id, const F32
 	mSyncSlave(false),
 	mQueueSounds(false),
 	mPlayedOnce(false),
-	mCorrupted(false),
 	mType(type),
 	// <edit>
 	mSourceID(source_id),
@@ -1375,27 +1372,16 @@ void LLAudioSource::setChannel(LLAudioChannel *channelp)
 
 void LLAudioSource::update()
 {
-	if(mCorrupted)
-	{
-		return ; //no need to update
-	}
-
 	if (!getCurrentBuffer())
 	{
-		LLAudioData *adp = getCurrentData();
-		if (adp)
+		if (getCurrentData())
 		{
 			// Hack - try and load the sound.  Will do this as a callback
 			// on decode later.
-			if (adp->load() && adp->getBuffer())
+			if (getCurrentData()->load())
 			{
-				play(adp->getID());
-			}
-			else if (adp->hasCompletedDecode())		// Only mark corrupted after decode is done
-			{
-				llwarns << "Marking LLAudioSource corrupted for " << adp->getID() << llendl;
-				mCorrupted = true ;
-			}
+				play(getCurrentData()->getID());
+			}			
 		}
 	}
 }
@@ -1516,11 +1502,6 @@ bool LLAudioSource::play(const LLUUID &audio_uuid)
 
 bool LLAudioSource::isDone() const
 {
-	if(mCorrupted)
-	{
-		return true ;
-	}
-
 	const F32 MAX_AGE = 60.f;
 	const F32 MAX_UNPLAYED_AGE = 15.f;
 	const F32 MAX_MUTED_AGE = 11.f;
@@ -1816,7 +1797,6 @@ LLAudioData::LLAudioData(const LLUUID &uuid) :
 	mBufferp(NULL),
 	mHasLocalData(false),
 	mHasDecodedData(false),
-	mHasCompletedDecode(false),
 	mHasValidData(true)
 {
 	if (uuid.isNull())
@@ -1828,17 +1808,16 @@ LLAudioData::LLAudioData(const LLUUID &uuid) :
 	if (gAudiop && gAudiop->hasDecodedFile(uuid))
 	{
 		// Already have a decoded version, don't need to decode it.
-		setHasLocalData(true);
-		setHasDecodedData(true);
-		setHasCompletedDecode(true);
+		mHasLocalData = true;
+		mHasDecodedData = true;
 	}
 	else if (gAssetStorage && gAssetStorage->hasLocalAsset(uuid, LLAssetType::AT_SOUND))
 	{
-		setHasLocalData(true);
+		mHasLocalData = true;
 	}
 }
 
-//return false when the audio file is corrupted.
+
 bool LLAudioData::load()
 {
 	// For now, just assume we're going to use one buffer per audiodata.
@@ -1854,7 +1833,7 @@ bool LLAudioData::load()
 	{
 		// No free buffers, abort.
 		llinfos << "Not able to allocate a new audio buffer, aborting." << llendl;
-		return true;
+		return false;
 	}
 
 	std::string uuid_str;

indra/llaudio/llaudioengine.h

@@ -239,15 +239,12 @@ protected:
 	// A list of all audio sources that are known to the viewer at this time.
 	// This is most likely a superset of the ones that we actually have audio
 	// data for, or are playing back.
-public://Jay: IDGAF
 	typedef std::map<LLUUID, LLAudioSource *> source_map;
-protected:
 	typedef std::map<LLUUID, LLAudioData *> data_map;
-	
-public://Jay: IDGAF
+
 	source_map mAllSources;
-protected:
 	data_map mAllData;
+
 	LLAudioChannel *mChannels[MAX_CHANNELS];
 
 	// Buffers needs to change into a different data structure, as the number of buffers
@@ -354,9 +351,6 @@ public:
 protected:
 	LLUUID			mID; // The ID of the source is that of the object if it's attached to an object.
 	LLUUID			mOwnerID;	// owner of the object playing the sound
-public:
-	const LLUUID &getOwnerID()		{ return mOwnerID; }
-protected:
 	F32				mPriority;
 	F32				mGain;
 	bool			mSourceMuted;
@@ -366,7 +360,6 @@ protected:
 	bool			mSyncSlave;
 	bool			mQueueSounds;
 	bool			mPlayedOnce;
-	bool            mCorrupted;
 	S32             mType;
 	LLVector3d		mPositionGlobal;
 	LLVector3		mVelocity;
@@ -408,12 +401,10 @@ public:
 
 	bool	hasLocalData() const		{ return mHasLocalData; }
 	bool	hasDecodedData() const		{ return mHasDecodedData; }
-	bool	hasCompletedDecode() const	{ return mHasCompletedDecode; }
 	bool	hasValidData() const		{ return mHasValidData; }
 
 	void	setHasLocalData(const bool hld)		{ mHasLocalData = hld; }
 	void	setHasDecodedData(const bool hdd)	{ mHasDecodedData = hdd; }
-	void	setHasCompletedDecode(const bool hcd)	{ mHasCompletedDecode = hcd; }
 	void	setHasValidData(const bool hvd)		{ mHasValidData = hvd; }
 
 	friend class LLAudioEngine; // Severe laziness, bad.
@@ -421,10 +412,9 @@ public:
 protected:
 	LLUUID mID;
 	LLAudioBuffer *mBufferp;	// If this data is being used by the audio system, a pointer to the buffer will be set here.
-	bool mHasLocalData;			// Set true if the sound asset file is available locally
-	bool mHasDecodedData;		// Set true if the sound file has been decoded
-	bool mHasCompletedDecode;	// Set true when the sound is decoded
-	bool mHasValidData;			// Set false if decoding failed, meaning the sound asset is bad
+	bool mHasLocalData;
+	bool mHasDecodedData;
+	bool mHasValidData;
 };
 
 

indra/llaudio/llaudioengine_fmodex.cpp

@@ -105,6 +105,10 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 
 	U32 version;
 	FMOD_RESULT result;
+	int numdrivers;
+	FMOD_SPEAKERMODE speakermode;
+	FMOD_CAPS caps;
+	char name[256];
 
 	LL_DEBUGS("AppInit") << "LLAudioEngine_FMODEX::init() initializing FMOD" << LL_ENDL;
 
@@ -120,16 +124,11 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 
 	if (version < FMOD_VERSION)
 	{
-		LL_WARNS("AppInit") << "Error : You are using the wrong FMOD Ex version (" << version
-			<< ")!  You should be using FMOD Ex" << FMOD_VERSION << LL_ENDL;
+		LL_WARNS("AppInit") << "Error : You are using the wrong FMOD version (" << version
+			<< ")!  You should be using FMOD " << FMOD_VERSION << LL_ENDL;
 	}
 
 #if LL_WINDOWS
-	int numdrivers;
-	FMOD_SPEAKERMODE speakermode;
-	FMOD_CAPS caps;
-	char name[256];
-
 	//Is this block applicable to linux?
 	{
 		result = mSystem->getNumDrivers(&numdrivers);
@@ -174,7 +173,7 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 #endif //LL_WINDOWS
 
 	// In this case, all sounds, PLUS wind and stream will be software.
-	result = mSystem->setSoftwareChannels(num_channels + 2);
+	result = mSystem->setSoftwareChannels(num_channels+2);
 	Check_FMOD_Error(result,"FMOD::System::setSoftwareChannels");
 
 	U32 fmod_flags = FMOD_INIT_NORMAL;
@@ -182,67 +181,73 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		fmod_flags |= FMOD_INIT_ENABLE_PROFILE;
 
 #if LL_LINUX
+	// If we don't set an output method, Linux FMOD always
+	// decides on OSS and fails otherwise.  So we'll manually
+	// try ESD, then OSS, then ALSA.
+	// Why this order?  See SL-13250, but in short, OSS emulated
+	// on top of ALSA is ironically more reliable than raw ALSA.
+	// Ack, and ESD has more reliable failure modes - but has worse
+	// latency - than all of them, so wins for now.
 	bool audio_ok = false;
 
 	if (!audio_ok)
 	{
-		if (NULL == getenv("LL_BAD_FMOD_PULSEAUDIO")) /*Flawfinder: ignore*/
+		if (NULL == getenv("LL_BAD_FMODEX_ESD")) /*Flawfinder: ignore*/
 		{
-			LL_DEBUGS("AppInit") << "Trying PulseAudio audio output..." << LL_ENDL;
-			if(mSystem->setOutput(FMOD_OUTPUTTYPE_PULSEAUDIO) == FMOD_OK &&
-				(result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
+			LL_DEBUGS("AppInit") << "Trying ESD audio output..." << LL_ENDL;
+			if(mSystem->SetOutput(FMOD_OUTPUTTYPE_ESD) == FMOD_OK &&
+				(result = mSystem->init(num_channels, fmod_flags, 0)) == FMOD_OK)
 			{
-				LL_DEBUGS("AppInit") << "PulseAudio output initialized OKAY"	<< LL_ENDL;
+				LL_DEBUGS("AppInit") << "ESD audio output initialized OKAY"	<< LL_ENDL;
 				audio_ok = true;
 			}
 			else 
 			{
-				Check_FMOD_Error(result, "PulseAudio audio output FAILED to initialize");
+				Check_FMOD_Error(result, "ESD audio output FAILED to initialize");
 			}
 		} 
 		else 
 		{
-			LL_DEBUGS("AppInit") << "PulseAudio audio output SKIPPED" << LL_ENDL;
+			LL_DEBUGS("AppInit") << "ESD audio output SKIPPED" << LL_ENDL;
 		}	
 	}
 	if (!audio_ok)
 	{
-		if (NULL == getenv("LL_BAD_FMOD_ALSA"))		/*Flawfinder: ignore*/
+		if (NULL == getenv("LL_BAD_FMODEX_OSS")) 	 /*Flawfinder: ignore*/
 		{
-			LL_DEBUGS("AppInit") << "Trying ALSA audio output..." << LL_ENDL;
-			if(mSystem->setOutput(FMOD_OUTPUTTYPE_ALSA) == FMOD_OK &&
-			    (result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
+			LL_DEBUGS("AppInit") << "Trying OSS audio output..." << LL_ENDL;
+			if(mSystem->SetOutput(FMOD_OUTPUTTYPE_OSS) == FMOD_OK &&
+			   (result = mSystem->init(num_channels, fmod_flags, 0)) == FMOD_OK)
 			{
-				LL_DEBUGS("AppInit") << "ALSA audio output initialized OKAY" << LL_ENDL;
+				LL_DEBUGS("AppInit") << "OSS audio output initialized OKAY" << LL_ENDL;
 				audio_ok = true;
 			} 
 			else 
 			{
-				Check_FMOD_Error(result, "ALSA audio output FAILED to initialize");
+				Check_FMOD_Error(result, "OSS audio output FAILED to initialize" << LL_ENDL;
 			}
 		} 
 		else 
 		{
-			LL_DEBUGS("AppInit") << "ALSA audio output SKIPPED" << LL_ENDL;
+			LL_DEBUGS("AppInit") << "OSS audio output SKIPPED" << LL_ENDL;
 		}
 	}
 	if (!audio_ok)
 	{
-		if (NULL == getenv("LL_BAD_FMOD_OSS")) 	 /*Flawfinder: ignore*/
+		if (NULL == getenv("LL_BAD_FMODEX_ALSA"))		/*Flawfinder: ignore*/
 		{
-			LL_DEBUGS("AppInit") << "Trying OSS audio output..." << LL_ENDL;
-			if(mSystem->setOutput(FMOD_OUTPUTTYPE_OSS) == FMOD_OK &&
-			    (result = mSystem->init(num_channels + 2, fmod_flags, 0)) == FMOD_OK)
+			LL_DEBUGS("AppInit") << "Trying ALSA audio output..." << LL_ENDL;
+			if(mSystem->SetOutput(FMOD_OUTPUTTYPE_ALSA) &&
+			   (result = mSystem->init(num_channels, fmod_flags, 0)) == FMOD_OK)
 			{
-				LL_DEBUGS("AppInit") << "OSS audio output initialized OKAY" << LL_ENDL;
+				LL_DEBUGS("AppInit") << "ALSA audio output initialized OKAY" << LL_ENDL;
 				audio_ok = true;
 			}
 			else
 			{
-				Check_FMOD_Error(result, "OSS audio output FAILED to initialize");
+				Check_FMOD_Error(result, "ALSA audio output FAILED to initialize");
 			}
-		}
-		else 
+		} else 
 		{
 			LL_DEBUGS("AppInit") << "OSS audio output SKIPPED" << LL_ENDL;
 		}
@@ -253,20 +258,25 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		return false;
 	}
 
+	// On Linux, FMOD causes a SIGPIPE for some netstream error
+	// conditions (an FMOD bug); ignore SIGPIPE so it doesn't crash us.
+	// NOW FIXED in FMOD 3.x since 2006-10-01.
+	//signal(SIGPIPE, SIG_IGN);
+
 	// We're interested in logging which output method we
 	// ended up with, for QA purposes.
 	FMOD_OUTPUTTYPE output_type;
-	mSystem->getOutput(&output_type);
+	mSystem->getOutput(output_type);
 	switch (output_type)
 	{
-		case FMOD_OUTPUTTYPE_NOSOUND: 
-			LL_INFOS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
-		case FMOD_OUTPUTTYPE_PULSEAUDIO:	
-			LL_INFOS("AppInit") << "Audio output: PulseAudio" << LL_ENDL; break;
-		case FMOD_OUTPUTTYPE_ALSA: 
-			LL_INFOS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
-		case FMOD_OUTPUTTYPE_OSS:	
-			LL_INFOS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
+		case FSOUND_OUTPUT_NOSOUND: 
+			LL_DEBUGS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
+		case FSOUND_OUTPUT_OSS:	
+			LL_DEBUGS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
+		case FSOUND_OUTPUT_ESD:	
+			LL_DEBUGS("AppInit") << "Audio output: ESD" << LL_ENDL; break;
+		case FSOUND_OUTPUT_ALSA: 
+			LL_DEBUGS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
 		default:
 			LL_INFOS("AppInit") << "Audio output: Unknown!" << LL_ENDL; break;
 	};
@@ -285,9 +295,9 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 		/*
 		... and re-init.
 		*/
-		result = mSystem->init( num_channels + 2, fmod_flags, 0);
+		result = mSystem->init(100, FMOD_INIT_NORMAL, 0);
 	}
-	if(Check_FMOD_Error(result, "Error initializing FMOD Ex"))
+	if(Check_FMOD_Error(result, "Error initializing FMOD"))
 		return false;
 #endif
 
@@ -295,7 +305,7 @@ bool LLAudioEngine_FMODEX::init(const S32 num_channels, void* userdata)
 	if (!getStreamingAudioImpl()) // no existing implementation added
 		setStreamingAudioImpl(new LLStreamingAudio_FMODEX(mSystem));
 
-	LL_INFOS("AppInit") << "LLAudioEngine_FMODEX::init() FMOD Ex initialized correctly" << LL_ENDL;
+	LL_DEBUGS("AppInit") << "LLAudioEngine_FMODEX::init() FMOD initialized correctly" << LL_ENDL;
 
 	mInited = true;
 
@@ -311,10 +321,10 @@ std::string LLAudioEngine_FMODEX::getDriverName(bool verbose)
 		U32 version;
 		if(!Check_FMOD_Error(mSystem->getVersion(&version), "FMOD::System::getVersion"))
 		{
-			return llformat("FMOD Ex %1x.%02x.%02x", version >> 16, version >> 8 & 0x000000FF, version & 0x000000FF);
+			return llformat("FMOD version %1x.%02x.%02x", version >> 16, version >> 8 & 0x000000FF, version & 0x000000FF);
 		}
 	}
-	return "FMODEx";
+	return "FMOD";
 }
 
 
@@ -332,13 +342,12 @@ void LLAudioEngine_FMODEX::shutdown()
 {
 	stopInternetStream();
 
-	llinfos << "About to LLAudioEngine::shutdown()" << llendl;
 	LLAudioEngine::shutdown();
 	
-	llinfos << "LLAudioEngine_FMODEX::shutdown() closing FMOD Ex" << llendl;
+	llinfos << "LLAudioEngine_FMODEX::shutdown() closing FMOD" << llendl;
 	mSystem->close();
 	mSystem->release();
-	llinfos << "LLAudioEngine_FMODEX::shutdown() done closing FMOD Ex" << llendl;
+	llinfos << "LLAudioEngine_FMODEX::shutdown() done closing FMOD" << llendl;
 
 	delete mListenerp;
 	mListenerp = NULL;

indra/llaudio/llstreamingaudio.h

@@ -53,11 +53,7 @@ class LLStreamingAudioInterface
 	virtual void setGain(F32 vol) = 0;
 	virtual F32 getGain() = 0;
 	virtual std::string getURL() = 0;
-
-	virtual bool supportsMetaData() = 0;
-	virtual const LLSD *getMetaData() = 0;
-	virtual bool supportsWaveData() = 0;
-	virtual bool getWaveData(float* arr, S32 count, S32 stride = 1) = 0;
+	virtual const LLSD *getMetaData() = 0;	//return NULL if not supported.
 };
 
 #endif // LL_STREAMINGAUDIO_H

indra/llaudio/llstreamingaudio_fmod.h

@@ -54,11 +54,8 @@ class LLStreamingAudio_FMOD : public LLStreamingAudioInterface
 	/*virtual*/ void setGain(F32 vol);
 	/*virtual*/ F32 getGain();
 	/*virtual*/ std::string getURL();
+	/*virtual*/ const LLSD *getMetaData(){return mMetaData;}	//return NULL if not supported.
 
-	/*virtual*/ bool supportsMetaData(){return true;}
-	/*virtual*/ const LLSD *getMetaData(){return mMetaData;}	//return NULL if not playing.
-	/*virtual*/ bool supportsWaveData(){return false;}
-	/*virtual*/ bool getWaveData(float* arr, S32 count, S32 stride = 1){return false;}
 private:
 	LLAudioStreamManagerFMOD *mCurrentInternetStreamp;
 	int mFMODInternetStreamChannel;

indra/llaudio/llstreamingaudio_fmodex.cpp

@@ -74,9 +74,7 @@ LLStreamingAudio_FMODEX::LLStreamingAudio_FMODEX(FMOD::System *system) :
 {
 	// Number of milliseconds of audio to buffer for the audio card.
 	// Must be larger than the usual Second Life frame stutter time.
-	const U32 buffer_seconds = 5;		//sec
-	const U32 estimated_bitrate = 128;	//kbit/sec
-	mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
+	mSystem->setStreamBufferSize(200, FMOD_TIMEUNIT_MS);
 
 	// Here's where we set the size of the network buffer and some buffering 
 	// parameters.  In this case we want a network buffer of 16k, we want it 
@@ -336,27 +334,6 @@ void LLStreamingAudio_FMODEX::setGain(F32 vol)
 	}
 }
 
-/*virtual*/ bool LLStreamingAudio_FMODEX::getWaveData(float* arr, S32 count, S32 stride/*=1*/)
-{
-	if(!mFMODInternetStreamChannelp || !mCurrentInternetStreamp)
-		return false;
-
-	static std::vector<float> local_array(count);	//Have to have an extra buffer to mix channels. Bleh.
-	if(count > (S32)local_array.size())	//Expand the array if needed. Try to minimize allocation calls, so don't ever shrink.
-		local_array.resize(count);
-
-	if(	mFMODInternetStreamChannelp->getWaveData(&local_array[0],count,0) == FMOD_OK &&
-		mFMODInternetStreamChannelp->getWaveData(&arr[0],count,1) == FMOD_OK )
-	{
-		for(S32 i = count-1;i>=0;i-=stride)
-		{
-			arr[i] += local_array[i];
-			arr[i] *= .5f;
-		}
-		return true;
-	}
-	return false;
-}
 
 ///////////////////////////////////////////////////////
 // manager of possibly-multiple internet audio streams
@@ -374,7 +351,7 @@ LLAudioStreamManagerFMODEX::LLAudioStreamManagerFMODEX(FMOD::System *system, con
 	exinfo.cbsize = sizeof(exinfo);
 	exinfo.suggestedsoundtype = FMOD_SOUND_TYPE_MPEG;	//Hint to speed up loading.
 
-	FMOD_RESULT result = mSystem->createStream(url.c_str(), FMOD_2D | FMOD_NONBLOCKING | FMOD_IGNORETAGS, &exinfo, &mInternetStream);
+	FMOD_RESULT result = mSystem->createStream(url.c_str(), FMOD_2D | FMOD_NONBLOCKING, &exinfo, &mInternetStream);
 
 	if (result!= FMOD_OK)
 	{

indra/llaudio/llstreamingaudio_fmodex.h

@@ -61,11 +61,8 @@ class LLStreamingAudio_FMODEX : public LLStreamingAudioInterface
 	/*virtual*/ void setGain(F32 vol);
 	/*virtual*/ F32 getGain();
 	/*virtual*/ std::string getURL();
+	/*virtual*/ const LLSD *getMetaData(){return mMetaData;}	//return NULL if not supported.
 
-	/*virtual*/ bool supportsMetaData(){return true;}
-	/*virtual*/ const LLSD *getMetaData(){return mMetaData;}	//return NULL if not playing.
-	/*virtual*/ bool supportsWaveData(){return true;}
-	/*virtual*/ bool getWaveData(float* arr, S32 count, S32 stride = 1);
 private:
 	FMOD::System *mSystem;
 

indra/llaudio/llvorbisdecode.cpp

@@ -133,10 +133,10 @@ BOOL decode_vorbis_file(LLVFS *vfs, const LLUUID &in_uuid, char *out_fname)
 		return(FALSE);
 	}
 
-	// **********************************
+	//**********************************
 	LLAPRFile outfile ;
 	outfile.open(out_fname,LL_APR_WPB);
-	// **********************************
+	//**********************************
 	if (!outfile.getFileHandle())
 	{
 		llwarning("unable to open vorbis destination file for writing",0);
@@ -308,9 +308,9 @@ BOOL decode_vorbis_file(LLVFS *vfs, const LLUUID &in_uuid, char *out_fname)
 	
 	outfile.seek(SEEK_END,-fade_length*2); 
 	outfile.write(pcmout,2*fade_length);  //write back xfaded last 16 samples
-	// *******************
+	//*******************
 	outfile.close();
-	// *******************
+	//*******************
 	
 	if ((36 == data_length) || (!(eof)))
 	{

indra/llaudio/llvorbisencode.cpp

@@ -87,10 +87,10 @@ S32 check_for_invalid_wav_formats(const std::string& in_fname, std::string& erro
 
 	error_msg.clear();
 
-	// ********************************
+	//********************************
 	LLAPRFile infile ;
-	infile.open(in_fname,LL_APR_RB);
-	// ********************************
+    infile.open(in_fname,LL_APR_RB);
+	//********************************
 	if (!infile.getFileHandle())
 	{
 		error_msg = "CannotUploadSoundFile";
@@ -159,9 +159,9 @@ S32 check_for_invalid_wav_formats(const std::string& in_fname, std::string& erro
 		file_pos += (chunk_length + 8);
 		chunk_length = 0;
 	} 
-	// ****************
+	//****************
 	infile.close();
-	// ****************
+	//****************
 
 	if (!uncompressed_pcm)
 	{	

indra/llcharacter/llbvhloader.cpp

@@ -44,7 +44,7 @@
 #include "llapr.h"
 
 
-//using namespace std;
+using namespace std;
 
 #define INCHES_TO_METERS 0.02540005f
 
@@ -1575,7 +1575,7 @@ BOOL LLBVHLoader::serialize(LLDataPacker& dp)
 		constraint_it++)
 		{
 			U8 byte = constraint_it->mChainLength;
-			dp.packU8(byte, "chain_length");
+			dp.packU8(byte, "chain_lenght");
 			
 			byte = constraint_it->mConstraintType;
 			dp.packU8(byte, "constraint_type");

indra/llcharacter/llcharacter.cpp

@@ -56,7 +56,8 @@ LLCharacter::LLCharacter()
 	mPreferredPelvisHeight( 0.f ),
 	mSex( SEX_FEMALE ),
 	mAppearanceSerialNum( 0 ),
-	mSkeletonSerialNum( 0 )
+	mSkeletonSerialNum( 0 ),
+	mInAppearance( false )
 {
 	llassert_always(sAllowInstancesChange) ;
 	sInstances.push_back(this);
@@ -194,19 +195,15 @@ void LLCharacter::requestStopMotion( LLMotion* motion)
 //-----------------------------------------------------------------------------
 // updateMotions()
 //-----------------------------------------------------------------------------
-static LLFastTimer::DeclareTimer FTM_UPDATE_ANIMATION("Update Animation");
-static LLFastTimer::DeclareTimer FTM_UPDATE_HIDDEN_ANIMATION("Update Hidden Anim");
-
 void LLCharacter::updateMotions(e_update_t update_type)
 {
+	LLFastTimer t(LLFastTimer::FTM_UPDATE_ANIMATION);
 	if (update_type == HIDDEN_UPDATE)
 	{
-		LLFastTimer t(FTM_UPDATE_HIDDEN_ANIMATION);
 		mMotionController.updateMotionsMinimal();
 	}
 	else
 	{
-		LLFastTimer t(FTM_UPDATE_ANIMATION);
 		// unpause if the number of outstanding pause requests has dropped to the initial one
 		if (mMotionController.isPaused() && mPauseRequest->getNumRefs() == 1)
 		{

indra/llcharacter/llcharacter.h

@@ -132,7 +132,7 @@ public:
 
 	virtual void addDebugText( const std::string& text ) = 0;
 
-	virtual const LLUUID&	getID() const = 0;
+	virtual const LLUUID&	getID() = 0;
 	//-------------------------------------------------------------------------
 	// End Interface
 	//-------------------------------------------------------------------------
@@ -268,6 +268,10 @@ public:
 	ESex getSex() const			{ return mSex; }
 	void setSex( ESex sex )		{ mSex = sex; }
 
+	// set appearance flag
+	void setAppearanceFlag( bool flag )	{ mInAppearance = flag; } 
+	bool getAppearanceFlag()			{ return mInAppearance; }
+
 	U32				getAppearanceSerialNum() const		{ return mAppearanceSerialNum; }
 	void			setAppearanceSerialNum( U32 num )	{ mAppearanceSerialNum = num; }
 	
@@ -289,6 +293,8 @@ protected:
 	U32					mSkeletonSerialNum;
 	LLAnimPauseRequest	mPauseRequest;
 
+	BOOL mInAppearance;
+
 private:
 	// visual parameter stuff
 	typedef std::map<S32, LLVisualParam *> 		visual_param_index_map_t;

indra/llcharacter/llgesture.cpp

@@ -1,25 +1,31 @@
 /** 
  * @file llgesture.cpp
  *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 

indra/llcharacter/llgesture.h

@@ -3,25 +3,31 @@
  * @brief A gesture is a combination of a triggering chat phrase or
  * key, a sound, an animation, and a chat string.
  *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 

indra/llcharacter/llheadrotmotion.cpp

@@ -510,6 +510,20 @@ BOOL LLEyeMotion::onUpdate(F32 time, U8* joint_mask)
 	vergence_quat.transQuat();
 	right_eye_rot = vergence_quat * eye_jitter_rot * right_eye_rot;
 
+	//if in appearance, set the eyes straight forward
+	if(mCharacter->getAppearanceFlag()) // no idea why this variable is reversed
+	{
+		LLVector3		forward(1.f, 0.0, 0.0);
+		LLVector3		left;
+		LLVector3		up;
+		left.setVec(forward % forward);
+		up.setVec(forward % left);
+		target_eye_rot = LLQuaternion(forward, left, up);
+		mLeftEyeState->setRotation( target_eye_rot );
+		mRightEyeState->setRotation( target_eye_rot );
+		return TRUE;
+	}
+
 	mLeftEyeState->setRotation( left_eye_rot );
 	mRightEyeState->setRotation( right_eye_rot );
 

indra/llcharacter/llkeyframemotion.cpp

@@ -480,7 +480,7 @@ LLPointer<LLJointState>& LLKeyframeMotion::getJointState(U32 index)
 }
 
 //-----------------------------------------------------------------------------
-// getJoint()
+// getJoin()
 //-----------------------------------------------------------------------------
 LLJoint* LLKeyframeMotion::getJoint(U32 index)
 {

indra/llcharacter/llmotioncontroller.cpp

@@ -637,9 +637,9 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
 			motionp->fadeIn();
 		}
 
-		// **********************
+		//**********************
 		// MOTION INACTIVE
-		// **********************
+		//**********************
 		if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
 		{
 			// this motion has gone on too long, deactivate it
@@ -659,9 +659,9 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
 			}
 		}
 
-		// **********************
+		//**********************
 		// MOTION EASE OUT
-		// **********************
+		//**********************
 		else if (motionp->isStopped() && mAnimTime > motionp->getStopTime())
 		{
 			// is this the first iteration in the ease out phase?
@@ -684,9 +684,9 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
 			update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
 		}
 
-		// **********************
+		//**********************
 		// MOTION ACTIVE
-		// **********************
+		//**********************
 		else if (mAnimTime > motionp->mActivationTimestamp + motionp->getEaseInDuration())
 		{
 			posep->setWeight(motionp->getFadeWeight());
@@ -707,9 +707,9 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
 			update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
 		}
 
-		// **********************
+		//**********************
 		// MOTION EASE IN
-		// **********************
+		//**********************
 		else if (mAnimTime >= motionp->mActivationTimestamp)
 		{
 			if (mLastTime < motionp->mActivationTimestamp)

indra/llcharacter/llmultigesture.cpp

@@ -2,25 +2,31 @@
  * @file llmultigesture.cpp
  * @brief Gestures that are asset-based and can have multiple steps.
  *
- * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 
@@ -44,7 +50,6 @@ const S32 GESTURE_VERSION = 2;
 LLMultiGesture::LLMultiGesture()
 :	mKey(),
 	mMask(),
-	mName(),
 	mTrigger(),
 	mReplaceText(),
 	mSteps(),
@@ -287,27 +292,20 @@ BOOL LLGestureStepAnimation::deserialize(LLDataPacker& dp)
 	dp.unpackU32(mFlags, "flags");
 	return TRUE;
 }
-// *NOTE: result is translated in LLPreviewGesture::getLabel()
-std::vector<std::string> LLGestureStepAnimation::getLabel() const 
+
+std::string LLGestureStepAnimation::getLabel() const
 {
-	std::vector<std::string> strings;
-	
-//	std::string label;
+	std::string label;
 	if (mFlags & ANIM_FLAG_STOP)
 	{
-		strings.push_back( "AnimFlagStop");
-
-//		label = "Stop Animation: ";
+		label = "Stop Animation: ";
 	}
 	else
 	{
-		strings.push_back( "AnimFlagStart");
-
-//		label = "Start Animation: "; 
+		label = "Start Animation: ";
 	}
-	strings.push_back( mAnimName);
-//	label += mAnimName;
-	return strings;
+	label += mAnimName;
+	return label;
 }
 
 void LLGestureStepAnimation::dump()
@@ -361,15 +359,12 @@ BOOL LLGestureStepSound::deserialize(LLDataPacker& dp)
 	dp.unpackU32(mFlags, "flags");
 	return TRUE;
 }
-// *NOTE: result is translated in LLPreviewGesture::getLabel()
-std::vector<std::string> LLGestureStepSound::getLabel() const
+
+std::string LLGestureStepSound::getLabel() const
 {
-	std::vector<std::string> strings;
-	strings.push_back( "Sound");
-	strings.push_back( mSoundName);	
-//	std::string label("Sound: ");
-//	label += mSoundName;
-	return strings;
+	std::string label("Sound: ");
+	label += mSoundName;
+	return label;
 }
 
 void LLGestureStepSound::dump()
@@ -419,13 +414,12 @@ BOOL LLGestureStepChat::deserialize(LLDataPacker& dp)
 	dp.unpackU32(mFlags, "flags");
 	return TRUE;
 }
-// *NOTE: result is translated in LLPreviewGesture::getLabel()
-std::vector<std::string> LLGestureStepChat::getLabel() const
+
+std::string LLGestureStepChat::getLabel() const
 {
-	std::vector<std::string> strings;
-	strings.push_back("Chat");
-	strings.push_back(mChatText);
-	return strings;
+	std::string label("Chat: ");
+	label += mChatText;
+	return label;
 }
 
 void LLGestureStepChat::dump()
@@ -473,31 +467,22 @@ BOOL LLGestureStepWait::deserialize(LLDataPacker& dp)
 	dp.unpackU32(mFlags, "flags");
 	return TRUE;
 }
-// *NOTE: result is translated in LLPreviewGesture::getLabel()
-std::vector<std::string> LLGestureStepWait::getLabel() const
+
+std::string LLGestureStepWait::getLabel() const
 {
-	std::vector<std::string> strings;
-	strings.push_back( "Wait" );
-	
-//	std::string label("--- Wait: ");
+	std::string label("--- Wait: ");
 	if (mFlags & WAIT_FLAG_TIME)
 	{
 		char buffer[64];		/* Flawfinder: ignore */
 		snprintf(buffer, sizeof(buffer), "%.1f seconds", (double)mWaitSeconds);	/* Flawfinder: ignore */
-		strings.push_back(buffer);
-//		label += buffer;
+		label += buffer;
 	}
 	else if (mFlags & WAIT_FLAG_ALL_ANIM)
 	{
-		strings.push_back("until animations are done");
-	//	label += "until animations are done";
-	}
-	else
-	{
-		strings.push_back("");
+		label += "until animations are done";
 	}
 
-	return strings;
+	return label;
 }
 
 

indra/llcharacter/llmultigesture.h

@@ -70,10 +70,6 @@ public:
 	KEY mKey;
 	MASK mMask;
 
-	// This name can be empty if the inventory item is not around and
-    // the gesture manager has not yet set the name
-	std::string mName;
-
 	// String, like "/foo" or "hello" that makes it play
 	std::string mTrigger;
 
@@ -134,7 +130,7 @@ public:
 	virtual EStepType getType() = 0;
 
 	// Return a user-readable label for this step
-	virtual std::vector<std::string> getLabel() const = 0;
+	virtual std::string getLabel() const = 0;
 
 	virtual S32 getMaxSerialSize() const = 0;
 	virtual BOOL serialize(LLDataPacker& dp) const = 0;
@@ -156,7 +152,7 @@ public:
 
 	virtual EStepType getType() { return STEP_ANIMATION; }
 
-	virtual std::vector<std::string> getLabel() const;
+	virtual std::string getLabel() const;
 
 	virtual S32 getMaxSerialSize() const;
 	virtual BOOL serialize(LLDataPacker& dp) const;
@@ -179,7 +175,7 @@ public:
 
 	virtual EStepType getType() { return STEP_SOUND; }
 
-	virtual std::vector<std::string> getLabel() const;
+	virtual std::string getLabel() const;
 
 	virtual S32 getMaxSerialSize() const;
 	virtual BOOL serialize(LLDataPacker& dp) const;
@@ -202,7 +198,7 @@ public:
 
 	virtual EStepType getType() { return STEP_CHAT; }
 
-	virtual std::vector<std::string> getLabel() const;
+	virtual std::string getLabel() const;
 
 	virtual S32 getMaxSerialSize() const;
 	virtual BOOL serialize(LLDataPacker& dp) const;
@@ -227,7 +223,7 @@ public:
 
 	virtual EStepType getType() { return STEP_WAIT; }
 
-	virtual std::vector<std::string> getLabel() const;
+	virtual std::string getLabel() const;
 
 	virtual S32 getMaxSerialSize() const;
 	virtual BOOL serialize(LLDataPacker& dp) const;

indra/llcharacter/llvisualparam.cpp

@@ -2,25 +2,31 @@
  * @file llvisualparam.cpp
  * @brief Implementation of LLPolyMesh class.
  *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 

indra/llcharacter/llvisualparam.h

@@ -2,25 +2,31 @@
  * @file llvisualparam.h
  * @brief Implementation of LLPolyMesh class.
  *
- * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 

indra/llcommon/CMakeLists.txt

@@ -15,11 +15,8 @@ include_directories(
     )
 
 set(llcommon_SOURCE_FILES
-	aiframetimer.cpp
 	imageids.cpp
-    indra_constants.cpp
-    llallocator.cpp
-    llallocator_heap_profile.cpp
+	indra_constants.cpp
     llapp.cpp
     llapr.cpp
     llaprpool.cpp
@@ -29,23 +26,16 @@ set(llcommon_SOURCE_FILES
     llbase64.cpp
     llcommon.cpp
     llcommonutils.cpp
-    llcoros.cpp
     llcrc.cpp
     llcriticaldamp.cpp
     llcursortypes.cpp
     lldate.cpp
-    lldependencies.cpp
     lldictionary.cpp
     llerror.cpp
     llerrorthread.cpp
     llevent.cpp
-    lleventapi.cpp
-    lleventcoro.cpp
-    lleventdispatcher.cpp
-    lleventfilter.cpp
-    llevents.cpp
     lleventtimer.cpp
-    llfasttimer_class.cpp
+    llfasttimer.cpp
     llfile.cpp
     llfindlocale.cpp
     llfixedbuffer.cpp
@@ -61,11 +51,9 @@ set(llcommon_SOURCE_FILES
     llmd5.cpp
     llmemory.cpp
     llmemorystream.cpp
-    llmemtype.cpp
     llmetrics.cpp
     llmortician.cpp
     lloptioninterface.cpp
-    llptrto.cpp 
     llprocesslauncher.cpp
     llprocessor.cpp
     llqueuedthread.cpp
@@ -91,7 +79,6 @@ set(llcommon_SOURCE_FILES
     lluri.cpp
     lluuid.cpp
     llworkerthread.cpp
-    ll_template_cast.h
     metaclass.cpp
     metaproperty.cpp
     reflective.cpp
@@ -102,7 +89,6 @@ set(llcommon_SOURCE_FILES
 set(llcommon_HEADER_FILES
     CMakeLists.txt
 
-    aiframetimer.h
     aithreadsafe.h
     bitpack.h
     ctype_workaround.h
@@ -112,8 +98,6 @@ set(llcommon_HEADER_FILES
     linden_common.h
     linked_lists.h
     llaccountingcost.h
-    llallocator.h
-    llallocator_heap_profile.h
     llagentconstants.h
     llavatarname.h
     llapp.h
@@ -121,7 +105,6 @@ set(llcommon_HEADER_FILES
     llaprpool.h
     llassettype.h
     llassoclist.h
-    llatomic.h
     llavatarconstants.h
     llbase32.h
     llbase64.h
@@ -130,7 +113,6 @@ set(llcommon_HEADER_FILES
     llclickaction.h
     llcommon.h
     llcommonutils.h
-    llcoros.h
     llcrc.h
     llcriticaldamp.h
     llcursortypes.h
@@ -138,7 +120,6 @@ set(llcommon_HEADER_FILES
     lldarrayptr.h
     lldate.h
     lldefs.h
-    lldependencies.h
     lldeleteutils.h
     lldepthstack.h
     lldictionary.h
@@ -151,16 +132,10 @@ set(llcommon_HEADER_FILES
     llerrorlegacy.h
     llerrorthread.h
     llevent.h
-    lleventapi.h
-    lleventcoro.h
-    lleventdispatcher.h
-    lleventfilter.h
-    llevents.h
     lleventemitter.h
     llextendedstatus.h
     lleventtimer.h
     llfasttimer.h
-    llfasttimer_class.h
     llfile.h
     llfindlocale.h
     llfixedbuffer.h
@@ -196,7 +171,6 @@ set(llcommon_HEADER_FILES
     llprocessor.h
     llptrskiplist.h
     llptrskipmap.h
-    llptrto.h
     llqueuedthread.h
     llrand.h
     llrefcount.h
@@ -229,7 +203,8 @@ set(llcommon_HEADER_FILES
     lluri.h
     lluuid.h
     lluuidhashmap.h
-    llversionviewer.h.in
+    llversionserver.h
+    llversionviewer.h
     llworkerthread.h
     metaclass.h
     metaclasst.h

indra/llcommon/aiframetimer.cpp

@@ -1,180 +0,0 @@
-/**
- * @file aiframetimer.cpp
- *
- * Copyright (c) 2011, Aleric Inglewood.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution.
- *
- * CHANGELOG
- *   and additional copyright holders.
- *
- *   06/08/2011
- *   - Initial version, written by Aleric Inglewood @ SL
- */
-
-// An AIFrameTimer object provides a callback API for timer events.
-//
-// Typical usage:
-//
-// // Any thread.
-// AIFrameTimer timer;
-//
-// ...
-// // Any thread (after successful construction is guaranteed).
-// timer.create(5.5, boost::bind(&the_callback, <optional params>));	// Call the_callback(<optional params>) in 5.5 seconds.
-//
-// The callback function is always called by the main thread and should therefore
-// be light weight.
-//
-// If timer.cancel() is called before the timer expires, then the callback
-// function isn't called. If cancel() is called by another thread than the
-// main thread, then it is possible that the callback function is called
-// even while still inside cancel(), but as soon as cancel() returned it
-// is guarenteed that the callback function won't be called anymore.
-// Hence, if the callback function is a member of some object then
-// cancel() must be called before the destruction of that object (ie from
-// it's destructor). Calling cancel() multiple times is not a problem.
-// Note: if cancel() is called while the callback function is being
-// called then cancel() will block until the callback function returned.
-//
-// The timer object can be reused (by calling create() again), but
-// only after either the callback function was called, or after cancel()
-// returned. Most notably, you can call create() again from inside the
-// callback function to "restart" the timer.
-//
-
-#include "linden_common.h"
-#include "aiframetimer.h"
-
-static F64 const NEVER = 1e16;				// 317 million years.
-
-F64 AIFrameTimer::sNextExpiration;
-AIFrameTimer::timer_list_type AIFrameTimer::sTimerList;
-LLMutex AIFrameTimer::sMutex;
-
-// Notes on thread-safety of AIRunningFrameTimer (continued from aiframetimer.h)
-//
-// Most notably, the constructor and init() should be called as follows:
-// 1) The object is constructed (AIRunningFrameTimer::AIRunningFrameTimer).
-// 2) The lock is obtained.
-// 3) The object is inserted in the list (operator<(AIRunningFrameTimer const&, AIRunningFrameTimer const&)).
-// 4) The object is initialized (AIRunningFrameTimer::init).
-// 5) The lock is released.
-// This assures that the object is not yet shared at the moment that it is initialized.
-
-void AIFrameTimer::create(F64 expiration, signal_type::slot_type const& slot)
-{
-	AIRunningFrameTimer new_timer(expiration, this);
-	sMutex.lock();
-	llassert(mHandle.mRunningTimer == sTimerList.end());	// Create may only be called when the timer isn't already running.
-	mHandle.init(sTimerList.insert(new_timer), slot);
-	sNextExpiration = sTimerList.begin()->expiration();
-	sMutex.unlock();
-}
-
-void AIFrameTimer::cancel(void)
-{
-	// In order to stop us from returning from cancel() while
-	// the callback function is being called (which is done
-	// in AIFrameTimer::handleExpiration after obtaining the
-	// mHandle.mMutex lock), we start with trying to obtain
-	// it here and as such wait till the callback function
-	// returned.
-    mHandle.mMutex.lock();
-	// Next we have to grab this lock in order to stop
-	// AIFrameTimer::handleExpiration from even entering
-	// in the case we manage to get it first.
-    sMutex.lock();
-    if (mHandle.mRunningTimer != sTimerList.end())
-	{
-		sTimerList.erase(mHandle.mRunningTimer);
-		mHandle.mRunningTimer = sTimerList.end();
-		sNextExpiration = sTimerList.empty() ? NEVER : sTimerList.begin()->expiration();
-	}
-    sMutex.unlock();
-    mHandle.mMutex.unlock();
-}
-
-void AIFrameTimer::handleExpiration(F64 current_frame_time)
-{
-    sMutex.lock();
-	for(;;)
-	{
-		if (sTimerList.empty())
-		{
-			// No running timers left.
-			sNextExpiration = NEVER;
-			break;
-		}
-		timer_list_type::iterator running_timer = sTimerList.begin();
-		sNextExpiration = running_timer->expiration();
-		if (sNextExpiration > current_frame_time)
-		{
-			// Didn't expire yet.
-			break;
-		}
-
-		// Obtain handle of running timer through the associated AIFrameTimer object.
-		// Note that if the AIFrameTimer object was destructed (when running_timer->getTimer()
-		// would return an invalid pointer) then it called cancel(), so we can't be here.
-		Handle& handle(running_timer->getTimer()->mHandle);
-		llassert_always(running_timer == handle.mRunningTimer);
-
-		// We're going to erase this timer, so stop cancel() from doing the same.
-		handle.mRunningTimer = sTimerList.end();
-
-		// We keep handle.mMutex during the callback to prevent the thread that
-		// owns the AIFrameTimer from deleting the callback function while we
-		// call it: in order to do so it first has to call cancel(), which will
-		// block until we release this mutex again, or we won't call the callback
-		// function here because the trylock fails.
-		//
-		// Assuming the main thread arrived here, there are two possible states
-		// for the other thread that tries to delete the callback function,
-		// right after calling the cancel() function too:
-		//
-		// 1. It hasn't obtained the first lock yet, we obtain the handle.mMutex
-		// lock and the other thread will stall on the first line of cancel().
-		// After do_callback returns, the other thread will do nothing because
-		// handle.mRunningTimer equals sTimerList.end(), exit the function and
-		// (possibly) delete the callback object, but that is ok as we already
-		// returned from the callback function.
-		//
-		// 2. It already called cancel() and hangs on the second line trying to
-		// obtain sMutex.lock(). The trylock below fails and we never call the
-		// callback function. We erase the running timer here and release sMutex
-		// at the end, after which the other thread does nothing because
-		// handle.mRunningTimer equals sTimerList.end(), exits the function and
-		// (possibly) deletes the callback object.
-		//
-		// Note that if the other thread actually obtained the sMutex then we
-		// can't be here: this is still inside the critical area of sMutex.
-		if (handle.mMutex.tryLock())			// If this fails then another thread is in the process of cancelling this timer, so do nothing.
-		{
-			sMutex.unlock();
-			running_timer->do_callback();		// May not throw exceptions.
-			sMutex.lock();
-			handle.mMutex.unlock();				// Allow other thread to return from cancel() and possibly delete the callback object.
-		}
-
-		// Erase the timer from the running list.
-		sTimerList.erase(running_timer);
-	}
-    sMutex.unlock();
-}
-

indra/llcommon/aiframetimer.h

@@ -1,155 +0,0 @@
-/**
- * @file aiframetimer.h
- * @brief Implementation of AIFrameTimer.
- *
- * Copyright (c) 2011, Aleric Inglewood.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution.
- *
- * CHANGELOG
- *   and additional copyright holders.
- *
- *   05/08/2011
- *   Initial version, written by Aleric Inglewood @ SL
- */
-
-#ifndef AIFRAMETIMER_H
-#define AIFRAMETIMER_H
-
-#include "llframetimer.h"
-#include "llthread.h"
-#include <boost/signals2.hpp>
-#include <set>
-
-class LL_COMMON_API AIFrameTimer
-{
-  protected:
-	typedef boost::signals2::signal<void (void)> signal_type;
-
-  private:
-	// Use separate struct for this object because it is non-copyable.
-	struct Signal {
-		signal_type mSignal;
-	};
-
-	// Notes on Thread-Safety
-	//
-	// This is the type of the objects stored in AIFrameTimer::sTimerList, and as such leans
-	// for it's thread-safety on the same lock as is used for that std::multiset as follows.
-	// An arbitrary thread can create, insert and initialize this object. Other threads can
-	// not access it until that has completed.
-	//
-	// After creation two threads can access it: the thread that created it (owns the
-	// AIFrameTimer object, which has an mHandle that points to this object), or the main
-	// thread by finding it in sTimerList.
-	//
-	// See aiframetimer.cpp for more notes.
-	class AIRunningFrameTimer {
-	  private:
-		F64 mExpire;						// Time at which the timer expires, in seconds since application start (compared to LLFrameTimer::sFrameTime).
-		AIFrameTimer* mTimer;				// The actual timer.
-		// Can be mutable, since only the mExpire is used for ordering this object in the multiset AIFrameTimer::sTimerList.
-		mutable Signal* mCallback;			// Pointer to callback struct, or NULL when the object wasn't added to sTimerList yet.
-
-	  public:
-		AIRunningFrameTimer(F64 expiration, AIFrameTimer* timer) : mExpire(LLFrameTimer::getElapsedSeconds() + expiration), mCallback(NULL), mTimer(timer) { }
-		~AIRunningFrameTimer() { delete mCallback; }
-
-		// This function is called after the final object was added to sTimerList (where it is initialized in-place).
-		void init(signal_type::slot_type const& slot) const
-			{
-			  // We may only call init() once.
-			  llassert(!mCallback);
-			  mCallback = new Signal;
-			  mCallback->mSignal.connect(slot);
-			}
-
-		// Order AIFrameTimer::sTimerList so that the timer that expires first is up front.
-		friend bool operator<(AIRunningFrameTimer const& ft1, AIRunningFrameTimer const& ft2) { return ft1.mExpire < ft2.mExpire; }
-
-		void do_callback(void) const { mCallback->mSignal(); }
-		F64 expiration(void) const { return mExpire; }
-		AIFrameTimer* getTimer(void) const { return mTimer; }
-
-#if LL_DEBUG
-		// May not copy this object after it was initialized.
-		AIRunningFrameTimer(AIRunningFrameTimer const& running_frame_timer) :
-			mExpire(running_frame_timer.mExpire), mCallback(running_frame_timer.mCallback), mTimer(running_frame_timer.mTimer)
-			{ llassert(!mCallback); }
-#endif
-	};
-
-	typedef std::multiset<AIRunningFrameTimer> timer_list_type;
-
-	static LLMutex sMutex;						// Mutex for the two global variables below.
-	static timer_list_type sTimerList;			// List with all running timers.
-	static F64 sNextExpiration;					// Cache of smallest value in sTimerList.
-	friend class LLFrameTimer;					// Access to sNextExpiration.
-
-	class Handle {
-	  public:
-		timer_list_type::iterator mRunningTimer;	// Points to the running timer, or to sTimerList.end() when not running.
-													// Access to this iterator is protected by the AIFrameTimer::sMutex!
-		LLMutex mMutex;								// A mutex used to protect us from deletion of the callback object while
-													// calling the callback function in the case of simultaneous expiration
-													// and cancellation by the thread owning the AIFrameTimer (by calling
-													// AIFrameTimer::cancel).
-
-		// Constructor for a not-running timer.
-		Handle(void) : mRunningTimer(sTimerList.end()) { }
-
-		// Actual initialization used by AIFrameTimer::create.
-		void init(timer_list_type::iterator const& running_timer, signal_type::slot_type const& slot)
-			{
-			  // Locking AIFrameTimer::sMutex is not neccessary here, because we're creating
-			  // the object and no other thread knows of mRunningTimer at this point.
-			  mRunningTimer = running_timer;
-			  mRunningTimer->init(slot);
-			}
-
-	  private:
-		// LLMutex has no assignment operator.
-	  	Handle& operator=(Handle const&) { return *this; }
-	};
-
-	Handle mHandle;
-
-  public:
-	// Construct an AIFrameTimer that is not running.
-	AIFrameTimer(void) { }
-
-	// Construction of a running AIFrameTimer with expiration time expiration in seconds, and callback slot.
-	AIFrameTimer(F64 expiration, signal_type::slot_type const& slot) { create(expiration, slot); }
-
-	// Destructing the AIFrameTimer object terminates the running timer (if still running).
-	// Note that cancel() must have returned BEFORE anything is destructed that would disallow the callback function to be called.
-	// So, if the AIFrameTimer is a member of an object whose callback function is called then cancel() has
-	// to be called manually (or from the destructor of THAT object), before that object is destructed.
-	// Cancel may be called multiple times.
-	~AIFrameTimer() { cancel(); }
-
-	void create(F64 expiration, signal_type::slot_type const& slot);
-	void cancel(void);
-
-	bool isRunning(void) const { bool running; sMutex.lock(); running = mHandle.mRunningTimer != sTimerList.end(); sMutex.unlock(); return running; }
-
-  protected:
-	static void handleExpiration(F64 current_frame_time);
-};
-
-#endif

indra/llcommon/aithreadsafe.h

@@ -26,65 +26,8 @@
  *
  *   31/03/2010
  *   Initial version, written by Aleric Inglewood @ SL
- *
- *   14/03/2012
- *   Added AIThreadSafeSingleThread and friends.
- *   Added AIAccessConst (and derived AIAccess from it) to allow read
- *   access to a const AIThreadSafeSimple.
  */
 
-// This file defines wrapper template classes for arbitrary types T
-// adding locking to the instance and shielding it from access
-// without first being locked.
-//
-// Locking and getting access works by creating a temporary (local)
-// access object that takes the wrapper class as argument. Creating
-// the access object obtains the lock, while destructing it releases
-// the lock.
-//
-// There are three types of wrapper classes:
-// AIThreadSafe, AIThreadSafeSimple and AIThreadSafeSingleThread.
-//
-// AIThreadSafe is for use with the access classes:
-// AIReadAccessConst, AIReadAccess and AIWriteAccess.
-//
-// AIThreadSafeSimple is for use with the access classes:
-// AIAccessConst and AIAccess.
-//
-// AIThreadSafeSingleThread is for use with the access classes:
-// AISTAccessConst and AISTAccess.
-//
-// AIReadAccessConst provides read access to a const AIThreadSafe.
-// AIReadAccess provides read access to a non-const AIThreadSafe.
-// AIWriteAccess provides read/write access to a non-const AIThreadSafe.
-//
-// AIAccessConst provides read access to a const AIThreadSafeSimple.
-// AIAccess provides read/write access to a non-const AIThreadSafeSimple.
-//
-// AISTAccessConst provides read access to a const AIThreadSafeSingleThread.
-// AISTAccess provides read/write access to a non-const AIThreadSafeSingleThread.
-//
-// Thus, AIThreadSafe is to protect objects with a read/write lock,
-// AIThreadSafeSimple is to protect objects with a single mutex,
-// and AIThreadSafeSingleThread doesn't do any locking but makes sure
-// (in Debug mode) that the wrapped object is only accessed by one thread.
-//
-// Each wrapper class allows its wrapped object to be constructed
-// with arbitrary parameters by using operator new with placement;
-// for example, to instantiate a class Foo with read/write locking:
-//
-// AIThreadSafe<Foo> foo(new (foo.memory()) Foo(param1, param2, ...));
-//
-// Each wrapper class has a derived class that end on 'DC' (which
-// stand for Default Constructed): AIThreadSafeDC, AIThreadSafeSimpleDC
-// and AIThreadSafeSingleThreadDC. The default constructors of those
-// wrapper classes cause the wrapped instance to be default constructed
-// as well. They also provide a general one-parameter constructor.
-// For example:
-//
-// AIThreadSafeDC<Foo> foo;			// Default constructed Foo.
-// AIThreadSafeDC<Foo> foo(3.4);	// Foo with one constructor parameter.
-//
 #ifndef AITHREADSAFE_H
 #define AITHREADSAFE_H
 
@@ -106,10 +49,15 @@
 template<typename T> struct AIReadAccessConst;
 template<typename T> struct AIReadAccess;
 template<typename T> struct AIWriteAccess;
-template<typename T> struct AIAccessConst;
 template<typename T> struct AIAccess;
-template<typename T> struct AISTAccessConst;
-template<typename T> struct AISTAccess;
+
+#if LL_WINDOWS
+template<typename T> class AIThreadSafeBits;
+template<typename T>
+struct AIThreadSafeWindowsHack {
+	AIThreadSafeWindowsHack(AIThreadSafeBits<T>& var, T* object);
+};
+#endif
 
 template<typename T>
 class AIThreadSafeBits
@@ -132,15 +80,10 @@ public:
 	// Only for use by AITHREADSAFE, see below.
 	void* memory() const { return const_cast<long*>(&mMemory[0]); }
 
-	// Cast a T* back to AIThreadSafeBits<T>. This is the inverse of memory().
-	template<typename T2>
-	  static AIThreadSafeBits<T2>* wrapper_cast(T2* ptr)
-	      { return reinterpret_cast<AIThreadSafeBits<T2>*>(reinterpret_cast<char*>(ptr) - offsetof(AIThreadSafeBits<T2>, mMemory[0])); }
-	template<typename T2>
-	  static AIThreadSafeBits<T2> const* wrapper_cast(T2 const* ptr)
-	      { return reinterpret_cast<AIThreadSafeBits<T2> const*>(reinterpret_cast<char const*>(ptr) - offsetof(AIThreadSafeBits<T2>, mMemory[0])); }
-
 protected:
+#if LL_WINDOWS
+	template<typename T2> friend struct AIThreadSafeWindowsHack;
+#endif
 	// Accessors.
 	T const* ptr() const { return reinterpret_cast<T const*>(mMemory); }
 	T* ptr() { return reinterpret_cast<T*>(mMemory); }
@@ -242,14 +185,6 @@ public:
 		llassert(object == AIThreadSafeBits<T>::ptr());
 #endif
 	}
-
-#if LL_DEBUG
-	// Can only be locked when there still exists an AIAccess object that
-	// references this object and will access it upon destruction.
-	// If the assertion fails, make sure that such AIAccess object is
-	// destructed before the deletion of this object.
-	~AIThreadSafe() { llassert(!mRWLock.isLocked()); }
-#endif
 };
 
 /**
@@ -259,39 +194,48 @@ public:
  *
  * <code>
  * Foo foo(x, y);
- * static Bar bar(0.1, true);
+ * static Bar bar;
  * </code>
  *
  * One can instantiate a thread-safe instance with
  *
  * <code>
  * AITHREADSAFE(Foo, foo, (x, y));
- * static AITHREADSAFE(Bar, bar, (0.1, true));
+ * static AITHREADSAFE(Bar, bar, );
  * </code>
  *
  * Note: This macro does not allow to allocate such object on the heap.
  *       If that is needed, have a look at AIThreadSafeDC.
  */
+#if LL_WINDOWS
+template<typename T>
+AIThreadSafeWindowsHack<T>::AIThreadSafeWindowsHack(AIThreadSafeBits<T>& var, T* object)
+{
+	llassert(object == var.ptr());
+}
+#define AITHREADSAFE(type, var, paramlist) \
+  AIThreadSafe<type> var(NULL); \
+  AIThreadSafeWindowsHack<type> dummy_##var(var, new (var.memory()) type paramlist)
+#else
 #define AITHREADSAFE(type, var, paramlist) AIThreadSafe<type> var(new (var.memory()) type paramlist)
+#endif
 
 /**
  * @brief A wrapper class for objects that need to be accessed by more than one thread.
  *
  * This class is the same as an AIThreadSafe wrapper, except that it can only
- * be used for default constructed objects, or constructed with one parameter.
+ * be used for default constructed objects.
  *
  * For example, instead of
  *
  * <code>
  * Foo foo;
- * Bar bar(3);
  * </code>
  *
  * One would use
  *
  * <code>
  * AIThreadSafeDC<Foo> foo;
- * AIThreadSafeDC<Bar> bar(3);
  * </code>
  *
  * The advantage over AITHREADSAFE is that this object can be allocated with
@@ -309,8 +253,6 @@ class AIThreadSafeDC : public AIThreadSafe<T>
 public:
 	// Construct a wrapper around a default constructed object.
 	AIThreadSafeDC(void) { new (AIThreadSafe<T>::ptr()) T; }
-	// Allow an arbitrary parameter to be passed for construction.
-	template<typename T2> AIThreadSafeDC(T2 const& val) { new (AIThreadSafe<T>::ptr()) T(val); }
 };
 
 /**
@@ -448,7 +390,6 @@ struct AIWriteAccess : public AIReadAccess<T>
  *
  * AIAccess<Foo> foo_w(foo);
  * // Use foo_w-> for read and write access.
- * </code>
  *
  * See also AIThreadSafe
  */
@@ -457,7 +398,6 @@ class AIThreadSafeSimple : public AIThreadSafeBits<T>
 {
 protected:
 	// Only this one may access the object (through ptr()).
-	friend struct AIAccessConst<T>;
 	friend struct AIAccess<T>;
 
 	// Locking control.
@@ -471,14 +411,6 @@ protected:
 public:
 	// Only for use by AITHREADSAFESIMPLE, see below.
 	AIThreadSafeSimple(T* object) { llassert(object == AIThreadSafeBits<T>::ptr()); }
-
-#if LL_DEBUG
-	// Can only be locked when there still exists an AIAccess object that
-	// references this object and will access it upon destruction.
-	// If the assertion fails, make sure that such AIAccess object is
-	// destructed before the deletion of this object.
-	~AIThreadSafeSimple() { llassert(!mMutex.isLocked()); }
-#endif
 };
 
 /**
@@ -488,14 +420,14 @@ public:
  *
  * <code>
  * Foo foo(x, y);
- * static Bar bar(0.1, true);
+ * static Bar bar;
  * </code>
  *
  * One can instantiate a thread-safe instance with
  *
  * <code>
  * AITHREADSAFESIMPLE(Foo, foo, (x, y));
- * static AITHREADSAFESIMPLE(Bar, bar, (0.1, true));
+ * static AITHREADSAFESIMPLE(Bar, bar, );
  * </code>
  *
  * Note: This macro does not allow to allocate such object on the heap.
@@ -507,20 +439,18 @@ public:
  * @brief A wrapper class for objects that need to be accessed by more than one thread.
  *
  * This class is the same as an AIThreadSafeSimple wrapper, except that it can only
- * be used for default constructed objects, or constructed with one parameter.
+ * be used for default constructed objects.
  *
  * For example, instead of
  *
  * <code>
  * Foo foo;
- * Bar bar(0.1);
  * </code>
  *
  * One would use
  *
  * <code>
  * AIThreadSafeSimpleDC<Foo> foo;
- * AIThreadSafeSimpleDC<Bar> bar(0.1);
  * </code>
  *
  * The advantage over AITHREADSAFESIMPLE is that this object can be allocated with
@@ -538,12 +468,10 @@ class AIThreadSafeSimpleDC : public AIThreadSafeSimple<T>
 public:
 	// Construct a wrapper around a default constructed object.
 	AIThreadSafeSimpleDC(void) { new (AIThreadSafeSimple<T>::ptr()) T; }
-	// Allow an arbitrary parameter to be passed for construction.
-	template<typename T2> AIThreadSafeSimpleDC(T2 const& val) { new (AIThreadSafeSimple<T>::ptr()) T(val); }
 
 protected:
 	// For use by AIThreadSafeSimpleDCRootPool
-	AIThreadSafeSimpleDC(LLAPRRootPool& parent) : AIThreadSafeSimple<T>(parent) { new (AIThreadSafeSimple<T>::ptr()) T; }
+	AIThreadSafeSimpleDC(LLAPRPool& parent) : AIThreadSafeSimple<T>(parent) { new (AIThreadSafeSimple<T>::ptr()) T; }
 };
 
 // Helper class for AIThreadSafeSimpleDCRootPool to assure initialization of
@@ -565,7 +493,7 @@ private:
  * for the internally used mutexes and condition, instead of using the current threads
  * root pool. The advantage of this is that it can be used for objects that need to
  * be accessed from the destructors of global objects (after main). The disadvantage
- * is that it's less efficient to use your own root pool, therefore its use should be
+ * is that it's less efficient to use your own root pool, therefore it's use should be
  * restricted to those cases where it is absolutely necessary.
  */
 template<typename T>
@@ -581,13 +509,13 @@ public:
 };
 
 /**
- * @brief Write lock object and provide read access.
+ * @brief Write lock object and provide read/write access.
  */
 template<typename T>
-struct AIAccessConst
+struct AIAccess
 {
-	//! Construct a AIAccessConst from a constant AIThreadSafeSimple.
-	AIAccessConst(AIThreadSafeSimple<T> const& wrapper) : mWrapper(const_cast<AIThreadSafeSimple<T>&>(wrapper))
+	//! Construct a AIAccess from a non-constant AIThreadSafeSimple.
+	AIAccess(AIThreadSafeSimple<T>& wrapper) : mWrapper(wrapper)
 #if AI_NEED_ACCESS_CC
 		, mIsCopyConstructed(false)
 #endif
@@ -596,12 +524,12 @@ struct AIAccessConst
 	}
 
 	//! Access the underlaying object for (read and) write access.
-	T const* operator->() const { return this->mWrapper.ptr(); }
+	T* operator->() const { return this->mWrapper.ptr(); }
 
 	//! Access the underlaying object for (read and) write access.
-	T const& operator*() const { return *this->mWrapper.ptr(); }
+	T& operator*() const { return *this->mWrapper.ptr(); }
 
-	~AIAccessConst()
+	~AIAccess()
 	{
 #if AI_NEED_ACCESS_CC
 	  if (mIsCopyConstructed) return;
@@ -610,229 +538,17 @@ struct AIAccessConst
 	}
 
 protected:
-	AIThreadSafeSimple<T>& mWrapper;		//!< Reference to the object that we provide access to.
+	AIThreadSafeSimple<T>& mWrapper;	//!< Reference to the object that we provide access to.
 
 #if AI_NEED_ACCESS_CC
 	bool mIsCopyConstructed;
 public:
-	AIAccessConst(AIAccessConst const& orig) : mWrapper(orig.mWrapper), mIsCopyConstructed(true) { }
+	AIAccess(AIAccess const& orig) : mWrapper(orig.mWrapper), mIsCopyConstructed(true) { }
 #else
 private:
 	// Disallow copy constructing directly.
-	AIAccessConst(AIAccessConst const&);
+	AIAccess(AIAccess const&);
 #endif
 };
 
-/**
- * @brief Write lock object and provide read/write access.
- */
-template<typename T>
-struct AIAccess : public AIAccessConst<T>
-{
-	//! Construct a AIAccess from a non-constant AIThreadSafeSimple.
-	AIAccess(AIThreadSafeSimple<T>& wrapper) : AIAccessConst<T>(wrapper) { }
-
-	//! Access the underlaying object for (read and) write access.
-	T* operator->() const { return this->mWrapper.ptr(); }
-
-	//! Access the underlaying object for (read and) write access.
-	T& operator*() const { return *this->mWrapper.ptr(); }
-};
-
-/**
- * @brief A wrapper class for objects that should only be accessed by a single thread.
- *
- * Use AITHREADSAFESINGLETHREAD to define instances of any type, and use AISTAccess
- * to get access to the instance.
- *
- * For example,
- *
- * <code>
- * class Foo { public: Foo(int, int); };
- *
- * AITHREADSAFESINGLETHREAD(Foo, foo, (2, 3));
- *
- * AISTAccess<Foo> foo_w(foo);
- * // Use foo_w-> for read and write access.
- * </code>
- */
-template<typename T>
-class AIThreadSafeSingleThread : public AIThreadSafeBits<T>
-{
-protected:
-	// Only these one may access the object (through ptr()).
-	friend struct AISTAccessConst<T>;
-	friend struct AISTAccess<T>;
-
-	// For use by AIThreadSafeSingleThreadDC.
-	AIThreadSafeSingleThread(void)
-#ifdef LL_DEBUG
-	  : mAccessed(false)
-#endif
-	{ }
-
-#ifdef LL_DEBUG
-	mutable bool mAccessed;
-	mutable apr_os_thread_t mTheadID;
-
-	void accessed(void) const
-	{
-	  if (!mAccessed)
-	  {
-		mAccessed = true;
-		mTheadID = apr_os_thread_current();
-	  }
-	  else
-	  {
-		llassert_always(apr_os_thread_equal(mTheadID, apr_os_thread_current()));
-	  }
-	}
-#endif
-
-public:
-	// Only for use by AITHREADSAFESINGLETHREAD, see below.
-	AIThreadSafeSingleThread(T* object)
-#ifdef LL_DEBUG
-	  : mAccessed(false)
-#endif
-	{
-	  llassert(object == AIThreadSafeBits<T>::ptr());
-	}
-
-private:
-	// Disallow copying or assignments.
-	AIThreadSafeSingleThread(AIThreadSafeSingleThread const&);
-	void operator=(AIThreadSafeSingleThread const&);
-};
-
-/**
- * @brief A wrapper class for objects that should only be accessed by a single thread.
- *
- * This class is the same as an AIThreadSafeSingleThread wrapper, except that it can only
- * be used for default constructed objects, or constructed with one parameter.
- *
- * For example, instead of
- *
- * <code>
- * Foo foo;
- * Bar bar(0.1);
- * </code>
- *
- * One would use
- *
- * <code>
- * AIThreadSafeSingleThreadDC<Foo> foo;
- * AIThreadSafeSingleThreadDC<Bar> bar(0.1);
- * </code>
- *
- * The advantage over AITHREADSAFESINGLETHREAD is that this object can be allocated with
- * new on the heap. For example:
- *
- * <code>
- * AIThreadSafeSingleThreadDC<Foo>* ptr = new AIThreadSafeSingleThreadDC<Foo>;
- * </code>
- *
- * which is not possible with AITHREADSAFESINGLETHREAD.
- *
- * This class is primarily intended to test if some (member) variable needs locking,
- * during development (in debug mode), and is therefore more flexible in that it
- * automatically converts to the underlying type, can be assigned to and can be
- * written to an ostream, as if it wasn't wrapped at all. This is to reduce the
- * impact on the source code.
- */
-template<typename T>
-class AIThreadSafeSingleThreadDC : public AIThreadSafeSingleThread<T>
-{
-public:
-	// Construct a wrapper around a default constructed object.
-	AIThreadSafeSingleThreadDC(void) { new (AIThreadSafeSingleThread<T>::ptr()) T; }
-	// Allow an arbitrary parameter to be passed for construction.
-	template<typename T2> AIThreadSafeSingleThreadDC(T2 const& val) { new (AIThreadSafeSingleThread<T>::ptr()) T(val); }
-
-	// Allow assigning with T.
-	AIThreadSafeSingleThreadDC& operator=(T const& val) { AIThreadSafeSingleThread<T>::accessed(); *AIThreadSafeSingleThread<T>::ptr() = val; return *this; }
-	// Allow writing to an ostream.
-	friend std::ostream& operator<<(std::ostream& os, AIThreadSafeSingleThreadDC const& wrapped_val) { wrapped_val.accessed(); return os << *wrapped_val.ptr(); }
-
-	// Automatic conversion to T.
-	operator T&(void) { AIThreadSafeSingleThread<T>::accessed(); return *AIThreadSafeSingleThread<T>::ptr(); }
-	operator T const&(void) const { AIThreadSafeSingleThread<T>::accessed(); return *AIThreadSafeSingleThread<T>::ptr(); }
-};
-
-/**
- * @brief Instantiate a static, global or local object of a given type wrapped in AIThreadSafeSingleThread, using an arbitrary constructor.
- *
- * For example, instead of doing
- *
- * <code>
- * Foo foo(x, y);
- * static Bar bar;
- * </code>
- *
- * One can instantiate a thread-safe instance with
- *
- * <code>
- * AITHREADSAFESINGLETHREAD(Foo, foo, (x, y));
- * static AITHREADSAFESINGLETHREAD(Bar, bar, );
- * </code>
- *
- * Note: This macro does not allow to allocate such object on the heap.
- *       If that is needed, have a look at AIThreadSafeSingleThreadDC.
- */
-#define AITHREADSAFESINGLETHREAD(type, var, paramlist) AIThreadSafeSingleThread<type> var(new (var.memory()) type paramlist)
-
-/**
- * @brief Access single threaded object for read access.
- */
-template<typename T>
-struct AISTAccessConst
-{
-	//! Construct a AISTAccessConst from a constant AIThreadSafeSingleThread.
-	AISTAccessConst(AIThreadSafeSingleThread<T> const& wrapper) : mWrapper(const_cast<AIThreadSafeSingleThread<T>&>(wrapper))
-	{
-#if LL_DEBUG
-	  wrapper.accessed();
-#endif
-	}
-
-	//! Access the underlaying object for read access.
-	T const* operator->() const { return this->mWrapper.ptr(); }
-
-	//! Access the underlaying object for read write access.
-	T const& operator*() const { return *this->mWrapper.ptr(); }
-
-protected:
-	AIThreadSafeSingleThread<T>& mWrapper;		//!< Reference to the object that we provide access to.
-
-#if AI_NEED_ACCESS_CC
-public:
-	AISTAccessConst(AISTAccessConst const& orig) : mWrapper(orig.mWrapper) { }
-#else
-private:
-	// Disallow copy constructing directly.
-	AISTAccessConst(AISTAccessConst const&);
-#endif
-};
-
-/**
- * @brief Access single threaded object for read/write access.
- */
-template<typename T>
-struct AISTAccess : public AISTAccessConst<T>
-{
-	//! Construct a AISTAccess from a non-constant AIThreadSafeSingleThread.
-	AISTAccess(AIThreadSafeSingleThread<T>& wrapper) : AISTAccessConst<T>(wrapper)
-	{
-#if LL_DEBUG
-	  wrapper.accessed();
-#endif
-	}
-
-	//! Access the underlaying object for (read and) write access.
-	T* operator->() const { return this->mWrapper.ptr(); }
-
-	//! Access the underlaying object for (read and) write access.
-	T& operator*() const { return *this->mWrapper.ptr(); }
-};
-
 #endif

indra/llcommon/doublelinkedlist.h

@@ -124,7 +124,7 @@ public:
 
 	// NOTE: This next two funtions are only included here 
 	// for those too familiar with the LLLinkedList template class.
-	// They are deprecated.  resetList() is unecessary while 
+	// They are depreciated.  resetList() is unecessary while 
 	// getCurrentData() is identical to getNextData() and has
 	// a misleading name.
 	//
@@ -604,7 +604,7 @@ BOOL LLDoubleLinkedList<DATA_TYPE>::checkData(const DATA_TYPE *data)
 
 // NOTE: This next two funtions are only included here 
 // for those too familiar with the LLLinkedList template class.
-// They are deprecated.  resetList() is unecessary while 
+// They are depreciated.  resetList() is unecessary while 
 // getCurrentData() is identical to getNextData() and has
 // a misleading name.
 //

indra/llcommon/indra_constants.h

@@ -153,6 +153,11 @@ const	char	LAND_LAYER_CODE					= 'L';
 const	char	WATER_LAYER_CODE				= 'W';
 const	char	WIND_LAYER_CODE					= '7';
 const	char	CLOUD_LAYER_CODE				= '8';
+// Extended land layer for Aurora Sim
+const   char    AURORA_LAND_LAYER_CODE          = 'M';
+const	char	AURORA_WATER_LAYER_CODE			= 'X';
+const   char    AURORA_WIND_LAYER_CODE          = '9';
+const   char    AURORA_CLOUD_LAYER_CODE         = ':';
 
 // keys
 // Bit masks for various keyboard modifier keys.
@@ -375,7 +380,7 @@ const U32 PARCEL_MEDIA_COMMAND_LOOP_SET = 13;
 const U32 MAP_ITEM_TELEHUB = 0x01;
 const U32 MAP_ITEM_PG_EVENT = 0x02;
 const U32 MAP_ITEM_MATURE_EVENT = 0x03;
-//const U32 MAP_ITEM_POPULAR = 0x04;		// No longer supported, 2009-03-02 KLW
+const U32 MAP_ITEM_POPULAR = 0x04;
 //const U32 MAP_ITEM_AGENT_COUNT = 0x05;
 const U32 MAP_ITEM_AGENT_LOCATIONS = 0x06;
 const U32 MAP_ITEM_LAND_FOR_SALE = 0x07;

indra/llcommon/ll_template_cast.h

@@ -1,177 +0,0 @@
-/**
- * @file   ll_template_cast.h
- * @author Nat Goodspeed
- * @date   2009-11-21
- * @brief  Define ll_template_cast function
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if ! defined(LL_LL_TEMPLATE_CAST_H)
-#define LL_LL_TEMPLATE_CAST_H
-
-/**
- * Implementation for ll_template_cast() (q.v.).
- *
- * Default implementation: trying to cast two completely unrelated types
- * returns 0. Typically you'd specify T and U as pointer types, but in fact T
- * can be any type that can be initialized with 0.
- */
-template <typename T, typename U>
-struct ll_template_cast_impl
-{
-    T operator()(U)
-    {
-        return 0;
-    }
-};
-
-/**
- * ll_template_cast<T>(some_value) is for use in a template function when
- * some_value might be of arbitrary type, but you want to recognize type T
- * specially.
- *
- * It's designed for use with pointer types. Example:
- * @code
- * struct SpecialClass
- * {
- *     void someMethod(const std::string&) const;
- * };
- *
- * template <class REALCLASS>
- * void somefunc(const REALCLASS& instance)
- * {
- *     const SpecialClass* ptr = ll_template_cast<const SpecialClass*>(&instance);
- *     if (ptr)
- *     {
- *         ptr->someMethod("Call method only available on SpecialClass");
- *     }
- * }
- * @endcode
- *
- * Why is this better than dynamic_cast<>? Because unless OtherClass is
- * polymorphic, the following won't even compile (gcc 4.0.1):
- * @code
- * OtherClass other;
- * SpecialClass* ptr = dynamic_cast<SpecialClass*>(&other);
- * @endcode
- * to say nothing of this:
- * @code
- * void function(int);
- * SpecialClass* ptr = dynamic_cast<SpecialClass*>(&function);
- * @endcode
- * ll_template_cast handles these kinds of cases by returning 0.
- */
-template <typename T, typename U>
-T ll_template_cast(U value)
-{
-    return ll_template_cast_impl<T, U>()(value);
-}
-
-/**
- * Implementation for ll_template_cast() (q.v.).
- *
- * Implementation for identical types: return same value.
- */
-template <typename T>
-struct ll_template_cast_impl<T, T>
-{
-    T operator()(T value)
-    {
-        return value;
-    }
-};
-
-/**
- * LL_TEMPLATE_CONVERTIBLE(dest, source) asserts that, for a value @c s of
- * type @c source, <tt>ll_template_cast<dest>(s)</tt> will return @c s --
- * presuming that @c source can be converted to @c dest by the normal rules of
- * C++.
- *
- * By default, <tt>ll_template_cast<dest>(s)</tt> will return 0 unless @c s's
- * type is literally identical to @c dest. (This is because of the
- * straightforward application of template specialization rules.) That can
- * lead to surprising results, e.g.:
- *
- * @code
- * Foo myFoo;
- * const Foo* fooptr = ll_template_cast<const Foo*>(&myFoo);
- * @endcode
- *
- * Here @c fooptr will be 0 because <tt>&myFoo</tt> is of type <tt>Foo*</tt>
- * -- @em not <tt>const Foo*</tt>. (Declaring <tt>const Foo myFoo;</tt> would
- * force the compiler to do the right thing.)
- *
- * More disappointingly:
- * @code
- * struct Base {};
- * struct Subclass: public Base {};
- * Subclass object;
- * Base* ptr = ll_template_cast<Base*>(&object);
- * @endcode
- *
- * Here @c ptr will be 0 because <tt>&object</tt> is of type
- * <tt>Subclass*</tt> rather than <tt>Base*</tt>. We @em want this cast to
- * succeed, but without our help ll_template_cast can't recognize it.
- *
- * The following would suffice:
- * @code
- * LL_TEMPLATE_CONVERTIBLE(Base*, Subclass*);
- * ...
- * Base* ptr = ll_template_cast<Base*>(&object);
- * @endcode
- *
- * However, as noted earlier, this is easily fooled:
- * @code
- * const Base* ptr = ll_template_cast<const Base*>(&object);
- * @endcode
- * would still produce 0 because we haven't yet seen:
- * @code
- * LL_TEMPLATE_CONVERTIBLE(const Base*, Subclass*);
- * @endcode
- *
- * @TODO
- * This macro should use Boost type_traits facilities for stripping and
- * re-adding @c const and @c volatile qualifiers so that invoking
- * LL_TEMPLATE_CONVERTIBLE(dest, source) will automatically generate all
- * permitted permutations. It's really not fair to the coder to require
- * separate:
- * @code
- * LL_TEMPLATE_CONVERTIBLE(Base*, Subclass*);
- * LL_TEMPLATE_CONVERTIBLE(const Base*, Subclass*);
- * LL_TEMPLATE_CONVERTIBLE(const Base*, const Subclass*);
- * @endcode
- *
- * (Naturally we omit <tt>LL_TEMPLATE_CONVERTIBLE(Base*, const Subclass*)</tt>
- * because that's not permitted by normal C++ assignment anyway.)
- */
-#define LL_TEMPLATE_CONVERTIBLE(DEST, SOURCE)   \
-template <>                                     \
-struct ll_template_cast_impl<DEST, SOURCE>      \
-{                                               \
-    DEST operator()(SOURCE wrapper)             \
-    {                                           \
-        return wrapper;                         \
-    }                                           \
-}
-
-#endif /* ! defined(LL_LL_TEMPLATE_CAST_H) */

indra/llcommon/llallocator.cpp

@@ -1,134 +0,0 @@
-/** 
- * @file llallocator.cpp
- * @brief Implementation of the LLAllocator class.
- *
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llallocator.h"
-
-#if LL_USE_TCMALLOC
-
-#include "google/heap-profiler.h"
-#include "google/commandlineflags_public.h"
-
-DECLARE_bool(heap_profile_use_stack_trace);
-//DECLARE_double(tcmalloc_release_rate);
-
-// static
-void LLAllocator::pushMemType(S32 type)
-{
-    if(isProfiling())
-    {
-    	PushMemType(type);
-    }
-}
-
-// static
-S32 LLAllocator::popMemType()
-{
-    if (isProfiling())
-    {
-    	return PopMemType();
-    }
-    else
-    {
-        return -1;
-    }
-}
-
-void LLAllocator::setProfilingEnabled(bool should_enable)
-{
-    // NULL disables dumping to disk
-    static char const * const PREFIX = NULL;
-    if(should_enable)
-    {
-		HeapProfilerSetUseStackTrace(false);
-        HeapProfilerStart(PREFIX);
-    }
-    else
-    {
-        HeapProfilerStop();
-    }
-}
-
-// static
-bool LLAllocator::isProfiling()
-{
-    return IsHeapProfilerRunning();
-}
-
-std::string LLAllocator::getRawProfile()
-{
-    // *TODO - fix google-perftools to accept an buffer to avoid this
-    // malloc-copy-free cycle.
-    char * buffer = GetHeapProfile();
-    std::string ret = buffer;
-    free(buffer);
-    return ret;
-}
-
-#else // LL_USE_TCMALLOC
-
-//
-// stub implementations for when tcmalloc is disabled
-//
-
-// static
-void LLAllocator::pushMemType(S32 type)
-{
-}
-
-// static
-S32 LLAllocator::popMemType()
-{
-    return -1;
-}
-
-void LLAllocator::setProfilingEnabled(bool should_enable)
-{
-}
-
-// static
-bool LLAllocator::isProfiling()
-{
-    return false;
-}
-
-std::string LLAllocator::getRawProfile()
-{
-    return std::string();
-}
-
-#endif // LL_USE_TCMALLOC
-
-LLAllocatorHeapProfile const & LLAllocator::getProfile()
-{
-    mProf.mLines.clear();
-
-    // *TODO - avoid making all these extra copies of things...
-    std::string prof_text = getRawProfile();
-    //std::cout << prof_text << std::endl;
-    mProf.parse(prof_text);
-    return mProf;
-}

indra/llcommon/llallocator.h

@@ -1,57 +0,0 @@
-/** 
- * @file llallocator.h
- * @brief Declaration of the LLAllocator class.
- *
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLALLOCATOR_H
-#define LL_LLALLOCATOR_H
-
-#include <string>
-
-#include "llmemtype.h"
-#include "llallocator_heap_profile.h"
-
-class LL_COMMON_API LLAllocator {
-    friend class LLMemoryView;
-    friend class LLMemType;
-
-private:
-	static void pushMemType(S32 type);
-	static S32 popMemType();
-
-public:
-    void setProfilingEnabled(bool should_enable);
-
-    static bool isProfiling();
-
-    LLAllocatorHeapProfile const & getProfile();
-
-private:
-    std::string getRawProfile();
-
-private:
-    LLAllocatorHeapProfile mProf;
-};
-
-#endif // LL_LLALLOCATOR_H

indra/llcommon/llallocator_heap_profile.cpp

@@ -1,147 +0,0 @@
-/** 
- * @file llallocator_heap_profile.cpp
- * @brief Implementation of the parser for tcmalloc heap profile data.
- * @author Brad Kittenbrink
- *
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include "llallocator_heap_profile.h"
-
-#if LL_MSVC
-// disable warning about boost::lexical_cast returning uninitialized data
-// when it fails to parse the string
-#pragma warning (disable:4701)
-#pragma warning (disable:4702)
-#endif
-
-#include <boost/algorithm/string/split.hpp>
-#include <boost/bind.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/range/iterator_range.hpp>
-
-static const std::string HEAP_PROFILE_MAGIC_STR = "heap profile:";
-
-static bool is_separator(char c)
-{
-    return isspace(c) || c == '[' || c == ']' || c == ':';
-}
-
-void LLAllocatorHeapProfile::parse(std::string const & prof_text)
-{
-    // a typedef for handling a token in the string buffer
-    // it's a begin/end pair of string::const_iterators
-    typedef boost::iterator_range<std::string::const_iterator> range_t;
-
-    mLines.clear();
-
-    if(prof_text.compare(0, HEAP_PROFILE_MAGIC_STR.length(), HEAP_PROFILE_MAGIC_STR) != 0)
-    {
-        // *TODO - determine if there should be some better error state than
-        // mLines being empty. -brad
-        llwarns << "invalid heap profile data passed into parser." << llendl;
-        return;
-    }
-
-    std::vector< range_t > prof_lines;
-
-    std::string::const_iterator prof_begin = prof_text.begin() + HEAP_PROFILE_MAGIC_STR.length();
-
-	range_t prof_range(prof_begin, prof_text.end());
-    boost::algorithm::split(prof_lines,
-        prof_range,
-        boost::bind(std::equal_to<llwchar>(), '\n', _1));
-
-    std::vector< range_t >::const_iterator i;
-    for(i = prof_lines.begin(); i != prof_lines.end() && !i->empty(); ++i)
-    {
-        range_t const & line_text = *i;
-
-        std::vector<range_t> line_elems;
-
-        boost::algorithm::split(line_elems,
-            line_text,
-            is_separator);
-
-        std::vector< range_t >::iterator j;
-        j = line_elems.begin();
-
-        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
-        llassert_always(j != line_elems.end());
-        U32 live_count = boost::lexical_cast<U32>(*j);
-        ++j;
-
-        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
-        llassert_always(j != line_elems.end());
-        U64 live_size = boost::lexical_cast<U64>(*j);
-        ++j;
-
-        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
-        llassert_always(j != line_elems.end());
-        U32 tot_count = boost::lexical_cast<U32>(*j);
-        ++j;
-
-        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
-        llassert_always(j != line_elems.end());
-        U64 tot_size = boost::lexical_cast<U64>(*j);
-        ++j;
-
-        while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
-	llassert(j != line_elems.end());
-        if (j != line_elems.end())
-	{
-		++j; // skip the '@'
-
-		mLines.push_back(line(live_count, live_size, tot_count, tot_size));
-		line & current_line = mLines.back();
-		
-		for(; j != line_elems.end(); ++j)
-		{
-			if(!j->empty())
-			{
-				U32 marker = boost::lexical_cast<U32>(*j);
-				current_line.mTrace.push_back(marker);
-			}
-		}
-	}
-    }
-    // *TODO - parse MAPPED_LIBRARIES section here if we're ever interested in it
-}
-
-void LLAllocatorHeapProfile::dump(std::ostream & out) const
-{
-    lines_t::const_iterator i;
-    for(i = mLines.begin(); i != mLines.end(); ++i)
-    {
-        out << i->mLiveCount << ": " << i->mLiveSize << '[' << i->mTotalCount << ": " << i->mTotalSize << "] @";
-
-        stack_trace::const_iterator j;
-        for(j = i->mTrace.begin(); j != i->mTrace.end(); ++j)
-        {
-            out << ' ' << *j;
-        }
-        out << '\n';
-    }
-    out.flush();
-}
-

indra/llcommon/llallocator_heap_profile.h

@@ -1,71 +0,0 @@
-/** 
- * @file llallocator_heap_profile.h
- * @brief Declaration of the parser for tcmalloc heap profile data.
- * @author Brad Kittenbrink
- *
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLALLOCATOR_HEAP_PROFILE_H
-#define LL_LLALLOCATOR_HEAP_PROFILE_H
-
-#include "stdtypes.h"
-
-#include <map>
-#include <vector>
-
-class LLAllocatorHeapProfile
-{
-public:
-    typedef int stack_marker;
-
-    typedef std::vector<stack_marker> stack_trace;
-
-    struct line {
-        line(U32 live_count, U64 live_size, U32 tot_count, U64 tot_size) :
-            mLiveSize(live_size),
-            mTotalSize(tot_size),
-            mLiveCount(live_count),
-            mTotalCount(tot_count)
-        {
-        }
-        U64 mLiveSize, mTotalSize;
-        U32 mLiveCount, mTotalCount;
-        stack_trace mTrace;
-    };
-
-    typedef std::vector<line> lines_t;
-
-    LLAllocatorHeapProfile()
-    {
-    }
-
-	void parse(std::string const & prof_text);
-
-    void dump(std::ostream & out) const;
-
-public:
-    lines_t mLines;
-};
-
-
-#endif // LL_LLALLOCATOR_HEAP_PROFILE_H

indra/llcommon/llapp.cpp

@@ -74,7 +74,7 @@ S32 LL_HEARTBEAT_SIGNAL = (SIGRTMAX >= 0) ? (SIGRTMAX-0) : SIGUSR2;
 // the static application instance
 LLApp* LLApp::sApplication = NULL;
 
-// Allows the generation of core files for post mortem under gdb
+// Allows the generation of core files for post mortum under gdb
 // and disables crashlogger
 BOOL LLApp::sDisableCrashlogger = FALSE; 
 
@@ -396,24 +396,11 @@ bool LLApp::isQuitting()
 	return (APP_STATUS_QUITTING == sStatus);
 }
 
-// static
 bool LLApp::isExiting()
 {
 	return isQuitting() || isError();
 }
 
-void LLApp::disableCrashlogger()
-{
-	// Disable Breakpad exception handler.
-	sDisableCrashlogger = TRUE;
-}
-
-// static
-bool LLApp::isCrashloggerDisabled()
-{
-	return (sDisableCrashlogger == TRUE); 
-}
-
 #if !LL_WINDOWS
 // static
 U32 LLApp::getSigChildCount()
@@ -747,7 +734,7 @@ void default_unix_signal_handler(int signum, siginfo_t *info, void *)
 				llwarns << "Signal handler - Flagging error status and waiting for shutdown" << llendl;
 			}
 									
-			if (LLApp::isCrashloggerDisabled())	// Don't gracefully handle any signal, crash and core for a gdb post mortem
+			if(LLApp::sDisableCrashlogger)	//Don't gracefully handle any signals crash and core for a gdb post mortum
 			{
 				clear_signals();
 				llwarns << "Fatal signal received, not handling the crash here, passing back to operating system" << llendl;

indra/llcommon/llapp.h

@@ -191,11 +191,6 @@ public:
 	//
 	virtual bool mainLoop() = 0; // Override for the application main loop.  Needs to at least gracefully notice the QUITTING state and exit.
 
-	//
-	// Crash logging
-	//
-	void disableCrashlogger();				// Let the OS handle the crashes
-	static bool isCrashloggerDisabled();	// Get the here above set value
 
 	//
 	// Application status
@@ -219,6 +214,9 @@ public:
 	//
 	void setErrorHandler(LLAppErrorHandler handler);
 	void setSyncErrorHandler(LLAppErrorHandler handler);
+
+	static BOOL sDisableCrashlogger; // Let the OS handle crashes for us.
+
 #if !LL_WINDOWS
 	//
 	// Child process handling (Unix only for now)
@@ -247,7 +245,6 @@ protected:
 	static void setStatus(EAppStatus status);		// Use this to change the application status.
 	static EAppStatus sStatus; // Reflects current application status
 	static BOOL sErrorThreadRunning; // Set while the error thread is running
-	static BOOL sDisableCrashlogger; // Let the OS handle crashes for us.
 
 #if !LL_WINDOWS
 	static LLAtomicU32* sSigChildCount; // Number of SIGCHLDs received.

indra/llcommon/llapr.cpp

@@ -88,7 +88,7 @@ bool ll_apr_warn_status(apr_status_t status)
 
 void ll_apr_assert_status(apr_status_t status)
 {
-	llassert(!ll_apr_warn_status(status));
+	llassert(ll_apr_warn_status(status) == false);
 }
 
 //---------------------------------------------------------------------
@@ -146,7 +146,7 @@ apr_status_t LLAPRFile::open(std::string const& filename, apr_int32_t flags, acc
 
 	apr_status_t status;
 	{
-		apr_pool_t* apr_file_open_pool;	// The use of apr_pool_t is OK here.
+		apr_pool_t* apr_file_open_pool;
 										// This is a temporary variable for a pool that is passed directly to apr_file_open below.
 		if (access_type == short_lived)
 		{
@@ -199,6 +199,7 @@ apr_status_t LLAPRFile::open(const std::string& filename, apr_int32_t flags, BOO
 // File I/O
 S32 LLAPRFile::read(void *buf, S32 nbytes)
 {
+	//llassert_always(mFile); (ASC-TUDCC) -HgB
 	if(!mFile) 
 	{
 		llwarns << "apr mFile is removed by somebody else. Can not read." << llendl ;
@@ -221,6 +222,7 @@ S32 LLAPRFile::read(void *buf, S32 nbytes)
 
 S32 LLAPRFile::write(const void *buf, S32 nbytes)
 {
+	// llassert_always(mFile); (ASC-TUDCC) -HgB
 	if(!mFile) 
 	{
 		llwarns << "apr mFile is removed by somebody else. Can not write." << llendl ;
@@ -247,7 +249,7 @@ S32 LLAPRFile::seek(apr_seek_where_t where, S32 offset)
 }
 
 //
-// *******************************************************************************************************************************
+//*******************************************************************************************************************************
 //static components of LLAPRFile
 //
 
@@ -502,5 +504,5 @@ bool LLAPRFile::removeDir(const std::string& dirname)
 }
 //
 //end of static components of LLAPRFile
-// *******************************************************************************************************************************
+//*******************************************************************************************************************************
 //

indra/llcommon/llapr.h

@@ -91,8 +91,29 @@ protected:
 	apr_thread_mutex_t* mMutex;
 };
 
+template <typename Type> class LLAtomic32
+{
+public:
+	LLAtomic32<Type>() {};
+	LLAtomic32<Type>(Type x) {apr_atomic_set32(&mData, apr_uint32_t(x)); };
+	~LLAtomic32<Type>() {};
+
+	operator const Type() { apr_uint32_t data = apr_atomic_read32(&mData); return Type(data); }
+	Type operator =(const Type& x) { apr_atomic_set32(&mData, apr_uint32_t(x)); return Type(mData); }
+	void operator -=(Type x) { apr_atomic_sub32(&mData, apr_uint32_t(x)); }
+	void operator +=(Type x) { apr_atomic_add32(&mData, apr_uint32_t(x)); }
+	Type operator ++(int) { return apr_atomic_inc32(&mData); } // Type++
+	Type operator --(int) { return apr_atomic_dec32(&mData); } // Type--
+	
+private:
+	apr_uint32_t mData;
+};
+
+typedef LLAtomic32<U32> LLAtomicU32;
+typedef LLAtomic32<S32> LLAtomicS32;
+
 // File IO convenience functions.
-// Returns NULL if the file fails to open, sets *sizep to file size if not NULL
+// Returns NULL if the file fails to openm sets *sizep to file size of not NULL
 // abbreviated flags
 #define LL_APR_R (APR_READ) // "r"
 #define LL_APR_W (APR_CREATE|APR_TRUNCATE|APR_WRITE) // "w"
@@ -110,7 +131,7 @@ protected:
 //      especially do not put some time-costly operations between open() and close().
 //      otherwise it might lock the APRFilePool.
 //there are two different apr_pools the APRFile can use:
-//      1, a temporary pool passed to an APRFile function, which is used within this function and only once.
+//      1, a temperary pool passed to an APRFile function, which is used within this function and only once.
 //      2, a global pool.
 //
 
@@ -147,7 +168,7 @@ public:
 	apr_file_t* getFileHandle() {return mFile;}	
 
 //
-// *******************************************************************************************************************************
+//*******************************************************************************************************************************
 //static components
 //
 private:
@@ -164,11 +185,11 @@ public:
 	// Returns bytes read/written, 0 if read/write fails:
 	static S32 readEx(const std::string& filename, void *buf, S32 offset, S32 nbytes);
 	static S32 writeEx(const std::string& filename, void *buf, S32 offset, S32 nbytes);
-// *******************************************************************************************************************************
+//*******************************************************************************************************************************
 };
 
 /**
- * @brief Function which appropriately logs error or remains quiet on
+ * @brief Function which approprately logs error or remains quiet on
  * APR_SUCCESS.
  * @return Returns <code>true</code> if status is an error condition.
  */

indra/llcommon/llaprpool.cpp

@@ -1,5 +1,5 @@
 /**
- * @file llaprpool.cpp
+ * @file LLAPRPool.cpp
  *
  * Copyright (c) 2010, Aleric Inglewood.
  *

indra/llcommon/llaprpool.h

@@ -1,5 +1,5 @@
 /**
- * @file llaprpool.h
+ * @file LLAPRPool.h
  * @brief Implementation of LLAPRPool.
  *
  * Copyright (c) 2010, Aleric Inglewood.
@@ -60,9 +60,9 @@ extern void ll_init_apr();
 class LL_COMMON_API LLAPRPool
 {
 protected:
-	apr_pool_t* mPool;			//!< Pointer to the underlaying pool. NULL if not initialized.
+	apr_pool_t* mPool;					//!< Pointer to the underlaying pool. NULL if not initialized.
 	LLAPRPool* mParent;			//!< Pointer to the parent pool, if any. Only valid when mPool is non-zero.
-	apr_os_thread_t mOwner;		//!< The thread that owns this memory pool. Only valid when mPool is non-zero.
+	apr_os_thread_t mOwner;				//!< The thread that owns this memory pool. Only valid when mPool is non-zero.
 
 public:
 	//! Construct an uninitialized (destructed) pool.

indra/llcommon/llassettype.cpp

@@ -214,16 +214,17 @@ LLAssetType::EType LLAssetType::lookupHumanReadable(const std::string& readable_
 bool LLAssetType::lookupCanLink(EType asset_type)
 {
 	//Check that enabling all these other types as linkable doesn't break things.
-	const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
+	/*const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
 	const AssetEntry *entry = dict->lookup(asset_type);
 	if (entry)
 	{
 		return entry->mCanLink;
 	}
 	return false;
+	*/
 	
-	/*return (asset_type == AT_CLOTHING || asset_type == AT_OBJECT || asset_type == AT_CATEGORY ||
-			asset_type == AT_BODYPART || asset_type == AT_GESTURE);*/
+	return (asset_type == AT_CLOTHING || asset_type == AT_OBJECT || asset_type == AT_CATEGORY ||
+			asset_type == AT_BODYPART || asset_type == AT_GESTURE);
 }
 
 // static

indra/llcommon/llatomic.h

@@ -1,61 +0,0 @@
-/** 
- * @file llatomic.h
- * @brief Definition of LLAtomic
- *
- * $LicenseInfo:firstyear=2004&license=viewergpl$
- * 
- * Copyright (c) 2004-2009, Linden Research, Inc.
- * Copyright (c) 2012, Aleric Inglewood
- * 
- * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
- * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at
- * http://secondlifegrid.net/programs/open_source/licensing/flossexception
- * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
- * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLATOMIC_H
-#define LL_LLATOMIC_H
-
-#include "apr_atomic.h"
-
-template <typename Type> class LLAtomic32
-{
-public:
-	LLAtomic32(void) { }
-	LLAtomic32(LLAtomic32 const& atom) { apr_uint32_t data = apr_atomic_read32(const_cast<apr_uint32_t*>(&atom.mData)); apr_atomic_set32(&mData, data); }
-	LLAtomic32(Type x) { apr_atomic_set32(&mData, static_cast<apr_uint32_t>(x)); }
-	LLAtomic32& operator=(LLAtomic32 const& atom) { apr_uint32_t data = apr_atomic_read32(const_cast<apr_uint32_t*>(&atom.mData)); apr_atomic_set32(&mData, data); return *this; }
-
-	operator Type() const { apr_uint32_t data = apr_atomic_read32(const_cast<apr_uint32_t*>(&mData)); return static_cast<Type>(data); }
-	void operator=(Type x) { apr_atomic_set32(&mData, static_cast<apr_uint32_t>(x)); }
-	void operator-=(Type x) { apr_atomic_sub32(&mData, static_cast<apr_uint32_t>(x)); }
-	void operator+=(Type x) { apr_atomic_add32(&mData, static_cast<apr_uint32_t>(x)); }
-	Type operator++(int) { return apr_atomic_inc32(&mData); } // Type++
-	bool operator--() { return apr_atomic_dec32(&mData); } // Returns (--Type != 0)
-	
-private:
-	apr_uint32_t mData;
-};
-
-typedef LLAtomic32<U32> LLAtomicU32;
-typedef LLAtomic32<S32> LLAtomicS32;
-
-#endif

indra/llcommon/llavatarname.cpp

@@ -99,7 +99,7 @@ std::string LLAvatarName::getCompleteName(bool linefeed) const
 	}
 	else
 	{
-		name = mDisplayName + (linefeed ? "\n(" : " (") + mUsername + ")";
+		name = mDisplayName + (linefeed ? "\n(" : "(") + mUsername + ")";
 	}
 	return name;
 }

indra/llcommon/llbase32.h

@@ -32,7 +32,7 @@
  */
 
 #ifndef LLBASE32_H
-#define LLBASE32_H
+#define LLBASE32_h
 
 class LL_COMMON_API LLBase32
 {

indra/llcommon/llbase64.h

@@ -32,7 +32,7 @@
  */
 
 #ifndef LLBASE64_H
-#define LLBASE64_H
+#define LLBASE64_h
 
 class LL_COMMON_API LLBase64
 {

indra/llcommon/llchat.h

@@ -75,15 +75,14 @@ public:
 	:	mText(text),
 		mFromName(),
 		mFromID(),
-
+// [RLVa:KB] - Checked: 2009-07-04 (RLVa-1.0.0a)
+		mRlvLocFiltered(FALSE),
+		mRlvNamesFiltered(FALSE),
+// [/RLVa:KB]
 		mSourceType(CHAT_SOURCE_AGENT),
 		mChatType(CHAT_TYPE_NORMAL),
 		mAudible(CHAT_AUDIBLE_FULLY),
 		mMuted(FALSE),
-// [RLVa:KB] - Checked: 2010-04-22 (RLVa-1.2.0f) | Modified: RLVa-1.0.0a
-		mRlvLocFiltered(FALSE),
-		mRlvNamesFiltered(FALSE),
-// [/RLVa:KB]
 		mTime(0.0),
 		mPosAgent(),
 		mURL()
@@ -105,14 +104,14 @@ public:
 	std::string		mText;		// UTF-8 line of text
 	std::string		mFromName;	// agent or object name
 	LLUUID			mFromID;	// agent id or object id
+// [RLVa:KB] - Checked: 2009-07-04 (RLVa-1.0.0a)
+	BOOL			mRlvLocFiltered;
+	BOOL			mRlvNamesFiltered;
+// [/RLVa:KB]
 	EChatSourceType	mSourceType;
 	EChatType		mChatType;
 	EChatAudible	mAudible;
 	BOOL			mMuted;		// pass muted chat to maintain list of chatters
-// [RLVa:KB] - Checked: 2010-04-22 (RLVa-1.2.0f) | Modified: RLVa-1.0.0a
-	BOOL			mRlvLocFiltered;
-	BOOL			mRlvNamesFiltered;
-// [/RLVa:KB]
 	F64				mTime;		// viewer only, seconds from viewer start
 	LLVector3		mPosAgent;
 	std::string		mURL;

indra/llcommon/llcommon.cpp

@@ -39,6 +39,7 @@ void LLCommon::initClass()
 {
 	LLMemory::initClass();
 	LLTimer::initClass();
+	LLThreadSafeRefCount::initThreadSafeRefCount();
 // 	LLWorkerThread::initClass();
 // 	LLFrameCallbackManager::initClass();
 }
@@ -48,6 +49,7 @@ void LLCommon::cleanupClass()
 {
 // 	LLFrameCallbackManager::cleanupClass();
 // 	LLWorkerThread::cleanupClass();
+	LLThreadSafeRefCount::cleanupThreadSafeRefCount();
 	LLTimer::cleanupClass();
 	LLMemory::cleanupClass();
 }

indra/llcommon/llcoros.cpp

@@ -1,154 +0,0 @@
-/**
- * @file   llcoros.cpp
- * @author Nat Goodspeed
- * @date   2009-06-03
- * @brief  Implementation for llcoros.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-#include "llcoros.h"
-// STL headers
-// std headers
-// external library headers
-#include <boost/bind.hpp>
-// other Linden headers
-#include "llevents.h"
-#include "llerror.h"
-#include "stringize.h"
-
-LLCoros::LLCoros()
-{
-    // Register our cleanup() method for "mainloop" ticks
-    LLEventPumps::instance().obtain("mainloop").listen(
-        "LLCoros", boost::bind(&LLCoros::cleanup, this, _1));
-}
-
-bool LLCoros::cleanup(const LLSD&)
-{
-    // Walk the mCoros map, checking and removing completed coroutines.
-    for (CoroMap::iterator mi(mCoros.begin()), mend(mCoros.end()); mi != mend; )
-    {
-        // Has this coroutine exited (normal return, exception, exit() call)
-        // since last tick?
-        if (mi->second->exited())
-        {
-            LL_INFOS("LLCoros") << "LLCoros: cleaning up coroutine " << mi->first << LL_ENDL;
-            // The erase() call will invalidate its passed iterator value --
-            // so increment mi FIRST -- but pass its original value to
-            // erase(). This is what postincrement is all about.
-            mCoros.erase(mi++);
-        }
-        else
-        {
-            // Still live, just skip this entry as if incrementing at the top
-            // of the loop as usual.
-            ++mi;
-        }
-    }
-    return false;
-}
-
-std::string LLCoros::generateDistinctName(const std::string& prefix) const
-{
-    // Allowing empty name would make getName()'s not-found return ambiguous.
-    if (prefix.empty())
-    {
-        LL_ERRS("LLCoros") << "LLCoros::launch(): pass non-empty name string" << LL_ENDL;
-    }
-
-    // If the specified name isn't already in the map, just use that.
-    std::string name(prefix);
-
-    // Find the lowest numeric suffix that doesn't collide with an existing
-    // entry. Start with 2 just to make it more intuitive for any interested
-    // parties: e.g. "joe", "joe2", "joe3"...
-    for (int i = 2; ; name = STRINGIZE(prefix << i++))
-    {
-        if (mCoros.find(name) == mCoros.end())
-        {
-            LL_INFOS("LLCoros") << "LLCoros: launching coroutine " << name << LL_ENDL;
-            return name;
-        }
-    }
-}
-
-bool LLCoros::kill(const std::string& name)
-{
-    CoroMap::iterator found = mCoros.find(name);
-    if (found == mCoros.end())
-    {
-        return false;
-    }
-    // Because this is a boost::ptr_map, erasing the map entry also destroys
-    // the referenced heap object, in this case the boost::coroutine object,
-    // which will terminate the coroutine.
-    mCoros.erase(found);
-    return true;
-}
-
-std::string LLCoros::getNameByID(const void* self_id) const
-{
-    // Walk the existing coroutines, looking for one from which the 'self_id'
-    // passed to us comes.
-    for (CoroMap::const_iterator mi(mCoros.begin()), mend(mCoros.end()); mi != mend; ++mi)
-    {
-        namespace coro_private = boost::coroutines::detail;
-        if (static_cast<void*>(coro_private::coroutine_accessor::get_impl(const_cast<coro&>(*mi->second)).get())
-            == self_id)
-        {
-            return mi->first;
-        }
-    }
-    return "";
-}
-
-/*****************************************************************************
-*   MUST BE LAST
-*****************************************************************************/
-// Turn off MSVC optimizations for just LLCoros::launchImpl() -- see
-// DEV-32777. But MSVC doesn't support push/pop for optimization flags as it
-// does for warning suppression, and we really don't want to force
-// optimization ON for other code even in Debug or RelWithDebInfo builds.
-
-#if LL_MSVC
-// work around broken optimizations
-#pragma warning(disable: 4748)
-#pragma optimize("", off)
-#endif // LL_MSVC
-
-std::string LLCoros::launchImpl(const std::string& prefix, coro* newCoro)
-{
-    std::string name(generateDistinctName(prefix));
-    mCoros.insert(name, newCoro);
-    /* Run the coroutine until its first wait, then return here */
-    (*newCoro)(std::nothrow);
-    return name;
-}
-
-#if LL_MSVC
-// reenable optimizations
-#pragma optimize("", on)
-#endif // LL_MSVC

indra/llcommon/llcoros.h

@@ -1,166 +0,0 @@
-/**
- * @file   llcoros.h
- * @author Nat Goodspeed
- * @date   2009-06-02
- * @brief  Manage running boost::coroutine instances
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if ! defined(LL_LLCOROS_H)
-#define LL_LLCOROS_H
-
-#include <boost/coroutine/coroutine.hpp>
-#include "llsingleton.h"
-#include <boost/ptr_container/ptr_map.hpp>
-#include <string>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/iteration/local.hpp>
-#include <stdexcept>
-
-/**
- * Registry of named Boost.Coroutine instances
- *
- * The Boost.Coroutine library supports the general case of a coroutine
- * accepting arbitrary parameters and yielding multiple (sets of) results. For
- * such use cases, it's natural for the invoking code to retain the coroutine
- * instance: the consumer repeatedly calls into the coroutine, perhaps passing
- * new parameter values, prompting it to yield its next result.
- *
- * Our typical coroutine usage is different, though. For us, coroutines
- * provide an alternative to the @c Responder pattern. Our typical coroutine
- * has @c void return, invoked in fire-and-forget mode: the handler for some
- * user gesture launches the coroutine and promptly returns to the main loop.
- * The coroutine initiates some action that will take multiple frames (e.g. a
- * capability request), waits for its result, processes it and silently steals
- * away.
- *
- * This usage poses two (related) problems:
- *
- * # Who should own the coroutine instance? If it's simply local to the
- *   handler code that launches it, return from the handler will destroy the
- *   coroutine object, terminating the coroutine.
- * # Once the coroutine terminates, in whatever way, who's responsible for
- *   cleaning up the coroutine object?
- *
- * LLCoros is a Singleton collection of currently-active coroutine instances.
- * Each has a name. You ask LLCoros to launch a new coroutine with a suggested
- * name prefix; from your prefix it generates a distinct name, registers the
- * new coroutine and returns the actual name.
- *
- * The name can be used to kill off the coroutine prematurely, if needed. It
- * can also provide diagnostic info: we can look up the name of the
- * currently-running coroutine.
- *
- * Finally, the next frame ("mainloop" event) after the coroutine terminates,
- * LLCoros will notice its demise and destroy it.
- */
-class LL_COMMON_API LLCoros: public LLSingleton<LLCoros>
-{
-public:
-    /// Canonical boost::coroutines::coroutine signature we use
-    typedef boost::coroutines::coroutine<void()> coro;
-    /// Canonical 'self' type
-    typedef coro::self self;
-
-    /**
-     * Create and start running a new coroutine with specified name. The name
-     * string you pass is a suggestion; it will be tweaked for uniqueness. The
-     * actual name is returned to you.
-     *
-     * Usage looks like this, for (e.g.) two coroutine parameters:
-     * @code
-     * class MyClass
-     * {
-     * public:
-     *     ...
-     *     // Do NOT NOT NOT accept reference params other than 'self'!
-     *     // Pass by value only!
-     *     void myCoroutineMethod(LLCoros::self& self, std::string, LLSD);
-     *     ...
-     * };
-     * ...
-     * std::string name = LLCoros::instance().launch(
-     *    "mycoro", boost::bind(&MyClass::myCoroutineMethod, this, _1,
-     *                          "somestring", LLSD(17));
-     * @endcode
-     *
-     * Your function/method must accept LLCoros::self& as its first parameter.
-     * It can accept any other parameters you want -- but ONLY BY VALUE!
-     * Other reference parameters are a BAD IDEA! You Have Been Warned. See
-     * DEV-32777 comments for an explanation.
-     *
-     * Pass a callable that accepts the single LLCoros::self& parameter. It
-     * may work to pass a free function whose only parameter is 'self'; for
-     * all other cases use boost::bind(). Of course, for a non-static class
-     * method, the first parameter must be the class instance. Use the
-     * placeholder _1 for the 'self' parameter. Any other parameters should be
-     * passed via the bind() expression.
-     *
-     * launch() tweaks the suggested name so it won't collide with any
-     * existing coroutine instance, creates the coroutine instance, registers
-     * it with the tweaked name and runs it until its first wait. At that
-     * point it returns the tweaked name.
-     */
-    template <typename CALLABLE>
-    std::string launch(const std::string& prefix, const CALLABLE& callable)
-    {
-        return launchImpl(prefix, new coro(callable));
-    }
-
-    /**
-     * Abort a running coroutine by name. Normally, when a coroutine either
-     * runs to completion or terminates with an exception, LLCoros quietly
-     * cleans it up. This is for use only when you must explicitly interrupt
-     * one prematurely. Returns @c true if the specified name was found and
-     * still running at the time.
-     */
-    bool kill(const std::string& name);
-
-    /**
-     * From within a coroutine, pass its @c self object to look up the
-     * (tweaked) name string by which this coroutine is registered. Returns
-     * the empty string if not found (e.g. if the coroutine was launched by
-     * hand rather than using LLCoros::launch()).
-     */
-    template <typename COROUTINE_SELF>
-    std::string getName(const COROUTINE_SELF& self) const
-    {
-        return getNameByID(self.get_id());
-    }
-
-    /// getName() by self.get_id()
-    std::string getNameByID(const void* self_id) const;
-
-private:
-    friend class LLSingleton<LLCoros>;
-    LLCoros();
-    std::string launchImpl(const std::string& prefix, coro* newCoro);
-    std::string generateDistinctName(const std::string& prefix) const;
-    bool cleanup(const LLSD&);
-
-    typedef boost::ptr_map<std::string, coro> CoroMap;
-    CoroMap mCoros;
-};
-
-#endif /* ! defined(LL_LLCOROS_H) */

indra/llcommon/llcursortypes.cpp

@@ -30,8 +30,6 @@
  * $/LicenseInfo$
  */
 
-#include "linden_common.h"
-
 #include "llcursortypes.h"
 
 ECursorType getCursorFromString(const std::string& cursor_string)
@@ -68,14 +66,14 @@ ECursorType getCursorFromString(const std::string& cursor_string)
 		cursor_string_table["UI_CURSOR_TOOLPAN"] = UI_CURSOR_TOOLPAN;
 		cursor_string_table["UI_CURSOR_TOOLZOOMIN"] = UI_CURSOR_TOOLZOOMIN;
 		cursor_string_table["UI_CURSOR_TOOLPICKOBJECT3"] = UI_CURSOR_TOOLPICKOBJECT3;
-		cursor_string_table["UI_CURSOR_TOOLPLAY"] = UI_CURSOR_TOOLPLAY;
-		cursor_string_table["UI_CURSOR_TOOLPAUSE"] = UI_CURSOR_TOOLPAUSE;
-		cursor_string_table["UI_CURSOR_TOOLMEDIAOPEN"] = UI_CURSOR_TOOLMEDIAOPEN;
-		cursor_string_table["UI_CURSOR_PIPETTE"] = UI_CURSOR_PIPETTE;
 		cursor_string_table["UI_CURSOR_TOOLSIT"] = UI_CURSOR_TOOLSIT;
 		cursor_string_table["UI_CURSOR_TOOLBUY"] = UI_CURSOR_TOOLBUY;
 		cursor_string_table["UI_CURSOR_TOOLPAY"] = UI_CURSOR_TOOLPAY;
 		cursor_string_table["UI_CURSOR_TOOLOPEN"] = UI_CURSOR_TOOLOPEN;
+		cursor_string_table["UI_CURSOR_TOOLPLAY"] = UI_CURSOR_TOOLPLAY;
+		cursor_string_table["UI_CURSOR_TOOLPAUSE"] = UI_CURSOR_TOOLPAUSE;
+		cursor_string_table["UI_CURSOR_TOOLMEDIAOPEN"] = UI_CURSOR_TOOLMEDIAOPEN;
+		cursor_string_table["UI_CURSOR_PIPETTE"] = UI_CURSOR_PIPETTE;
 	}
 
 	std::map<std::string,U32>::const_iterator iter = cursor_string_table.find(cursor_string);

indra/llcommon/llcursortypes.h

@@ -33,6 +33,8 @@
 #ifndef LL_LLCURSORTYPES_H
 #define LL_LLCURSORTYPES_H
 
+#include "linden_common.h"
+
 // If you add types here, add them in LLCursor::getCursorFromString
 enum ECursorType {
 	UI_CURSOR_ARROW,
@@ -64,14 +66,14 @@ enum ECursorType {
 	UI_CURSOR_TOOLPAN,
 	UI_CURSOR_TOOLZOOMIN,
 	UI_CURSOR_TOOLPICKOBJECT3,
-	UI_CURSOR_TOOLPLAY,
-	UI_CURSOR_TOOLPAUSE,
-	UI_CURSOR_TOOLMEDIAOPEN,
-	UI_CURSOR_PIPETTE,
 	UI_CURSOR_TOOLSIT,
 	UI_CURSOR_TOOLBUY,
 	UI_CURSOR_TOOLPAY,
 	UI_CURSOR_TOOLOPEN,
+	UI_CURSOR_TOOLPLAY,
+	UI_CURSOR_TOOLPAUSE,
+	UI_CURSOR_TOOLMEDIAOPEN,
+	UI_CURSOR_PIPETTE,
 	UI_CURSOR_COUNT			// Number of elements in this enum (NOT a cursor)
 };
 

indra/llcommon/lldate.cpp

@@ -43,7 +43,6 @@
 #include <iomanip>
 #include <sstream>
 
-#include "llfasttimer.h"
 #include "lltimer.h"
 #include "llstring.h"
 
@@ -95,11 +94,9 @@ std::string LLDate::asRFC1123() const
 	return toHTTPDateString (std::string ("%A, %d %b %Y %H:%M:%S GMT"));
 }
 
-LLFastTimer::DeclareTimer FT_DATE_FORMAT("Date Format");
 
 std::string LLDate::toHTTPDateString (std::string fmt) const
 {
-	LLFastTimer ft1(FT_DATE_FORMAT);
 	
 	time_t locSeconds = (time_t) mSecondsSinceEpoch;
 	struct tm * gmt = gmtime (&locSeconds);
@@ -108,7 +105,7 @@ std::string LLDate::toHTTPDateString (std::string fmt) const
 
 std::string LLDate::toHTTPDateString (tm * gmt, std::string fmt)
 {
-	LLFastTimer ft1(FT_DATE_FORMAT);
+        // Return Epoch UTC date
 
 	// avoid calling setlocale() unnecessarily - it's expensive.
 	static std::string prev_locale = "";

indra/llcommon/lldependencies.cpp

@@ -1,103 +0,0 @@
-/**
- * @file   lldependencies.cpp
- * @author Nat Goodspeed
- * @date   2008-09-17
- * @brief  Implementation for lldependencies.
- * 
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-#include "lldependencies.h"
-// STL headers
-#include <map>
-#include <sstream>
-// std headers
-// external library headers
-#include <boost/graph/graph_traits.hpp>  // for boost::graph_traits
-#include <boost/graph/adjacency_list.hpp>
-#include <boost/graph/topological_sort.hpp>
-#include <boost/graph/exception.hpp>
-// other Linden headers
-
-LLDependenciesBase::VertexList LLDependenciesBase::topo_sort(int vertices, const EdgeList& edges) const
-{
-    // Construct a Boost Graph Library graph according to the constraints
-    // we've collected. It seems as though we ought to be able to capture
-    // the uniqueness of vertex keys using a setS of vertices with a
-    // string property -- but I don't yet understand adjacency_list well
-    // enough to get there. All the examples I've seen so far use integers
-    // for vertices.
-    // Define the Graph type. Use a vector for vertices so we can use the
-    // default topological_sort vertex lookup by int index. Use a set for
-    // edges because the same dependency may be stated twice: Node "a" may
-    // specify that it must precede "b", while "b" may also state that it
-    // must follow "a".
-    typedef boost::adjacency_list<boost::setS, boost::vecS, boost::directedS,
-                                  boost::no_property> Graph;
-    // Instantiate the graph. Without vertex properties, we need say no
-    // more about vertices than the total number.
-    Graph g(edges.begin(), edges.end(), vertices);
-    // topo sort
-    typedef boost::graph_traits<Graph>::vertex_descriptor VertexDesc;
-    typedef std::vector<VertexDesc> SortedList;
-    SortedList sorted;
-    // note that it throws not_a_dag if it finds a cycle
-    try
-    {
-        boost::topological_sort(g, std::back_inserter(sorted));
-    }
-    catch (const boost::not_a_dag& e)
-    {
-        // translate to the exception we define
-        std::ostringstream out;
-        out << "LLDependencies cycle: " << e.what() << '\n';
-        // Omit independent nodes: display only those that might contribute to
-        // the cycle.
-        describe(out, false);
-        throw Cycle(out.str());
-    }
-    // A peculiarity of boost::topological_sort() is that it emits results in
-    // REVERSE topological order: to get the result you want, you must
-    // traverse the SortedList using reverse iterators.
-    return VertexList(sorted.rbegin(), sorted.rend());
-}
-
-std::ostream& LLDependenciesBase::describe(std::ostream& out, bool full) const
-{
-    // Should never encounter this base-class implementation; may mean that
-    // the KEY type doesn't have a suitable ostream operator<<().
-    out << "<no description available>";
-    return out;
-}
-
-std::string LLDependenciesBase::describe(bool full) const
-{
-    // Just use the ostream-based describe() on a std::ostringstream. The
-    // implementation is here mostly so that we can avoid #include <sstream>
-    // in the header file.
-    std::ostringstream out;
-    describe(out, full);
-    return out.str();
-}

indra/llcommon/lldependencies.h

@@ -1,799 +0,0 @@
-/**
- * @file   lldependencies.h
- * @author Nat Goodspeed
- * @date   2008-09-17
- * @brief  LLDependencies: a generic mechanism for expressing "b must follow a,
- *         but precede c"
- *
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if ! defined(LL_LLDEPENDENCIES_H)
-#define LL_LLDEPENDENCIES_H
-
-#include <string>
-#include <vector>
-#include <set>
-#include <map>
-#include <stdexcept>
-#include <iosfwd>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/iterator/indirect_iterator.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-
-/*****************************************************************************
-*   Utilities
-*****************************************************************************/
-/**
- * generic range transformer: given a range acceptable to Boost.Range (e.g. a
- * standard container, an iterator pair, ...) and a unary function to apply to
- * each element of the range, make a corresponding range that lazily applies
- * that function to each element on dereferencing.
- */
-template<typename FUNCTION, typename RANGE>
-inline
-boost::iterator_range<boost::transform_iterator<FUNCTION,
-                                                typename boost::range_const_iterator<RANGE>::type> >
-make_transform_range(const RANGE& range, FUNCTION function)
-{
-    // shorthand for the iterator type embedded in our return type
-    typedef boost::transform_iterator<FUNCTION, typename boost::range_const_iterator<RANGE>::type>
-        transform_iterator;
-    return boost::make_iterator_range(transform_iterator(boost::begin(range), function),
-                                      transform_iterator(boost::end(range),   function));
-}
-
-/// non-const version of make_transform_range()
-template<typename FUNCTION, typename RANGE>
-inline
-boost::iterator_range<boost::transform_iterator<FUNCTION,
-                                                typename boost::range_iterator<RANGE>::type> >
-make_transform_range(RANGE& range, FUNCTION function)
-{
-    // shorthand for the iterator type embedded in our return type
-    typedef boost::transform_iterator<FUNCTION, typename boost::range_iterator<RANGE>::type>
-        transform_iterator;
-    return boost::make_iterator_range(transform_iterator(boost::begin(range), function),
-                                      transform_iterator(boost::end(range),   function));
-}
-
-/**
- * From any range compatible with Boost.Range, instantiate any class capable
- * of accepting an iterator pair.
- */
-template<class TYPE>
-struct instance_from_range: public TYPE
-{
-    template<typename RANGE>
-    instance_from_range(RANGE range):
-        TYPE(boost::begin(range), boost::end(range))
-    {}
-};
-
-/*****************************************************************************
-*   LLDependencies
-*****************************************************************************/
-/**
- * LLDependencies components that should not be reinstantiated for each KEY,
- * NODE specialization
- */
-class LL_COMMON_API LLDependenciesBase
-{
-public:
-    virtual ~LLDependenciesBase() {}
-
-    /**
-     * Exception thrown by sort() if there's a cycle
-     */
-    struct Cycle: public std::runtime_error
-    {
-        Cycle(const std::string& what): std::runtime_error(what) {}
-    };
-
-    /**
-     * Provide a short description of this LLDependencies instance on the
-     * specified output stream, assuming that its KEY type has an operator<<()
-     * that works with std::ostream.
-     *
-     * Pass @a full as @c false to omit any keys without dependency constraints.
-     */
-    virtual std::ostream& describe(std::ostream& out, bool full=true) const;
-
-    /// describe() to a string
-    virtual std::string describe(bool full=true) const;
-
-protected:
-    typedef std::vector< std::pair<int, int> > EdgeList;
-    typedef std::vector<int> VertexList;
-    VertexList topo_sort(int vertices, const EdgeList& edges) const;
-
-    /**
-     * refpair is specifically intended to capture a pair of references. This
-     * is better than std::pair<T1&, T2&> because some implementations of
-     * std::pair's ctor accept const references to the two types. If the
-     * types are themselves references, this results in an illegal reference-
-     * to-reference.
-     */
-    template<typename T1, typename T2>
-    struct refpair
-    {
-        refpair(T1 value1, T2 value2):
-            first(value1),
-            second(value2)
-        {}
-        T1 first;
-        T2 second;
-    };
-};
-
-/// describe() helper: for most types, report the type as usual
-template<typename T>
-inline
-std::ostream& LLDependencies_describe(std::ostream& out, const T& key)
-{
-    out << key;
-    return out;
-}
-
-/// specialize LLDependencies_describe() for std::string
-template<>
-inline
-std::ostream& LLDependencies_describe(std::ostream& out, const std::string& key)
-{
-    out << '"' << key << '"';
-    return out;
-}
-
-/**
- * It's reasonable to use LLDependencies in a keys-only way, more or less like
- * std::set. For that case, the default NODE type is an empty struct.
- */
-struct LLDependenciesEmpty
-{
-    LLDependenciesEmpty() {}
-    /**
-     * Give it a constructor accepting void* so caller can pass placeholder
-     * values such as NULL or 0 rather than having to write
-     * LLDependenciesEmpty().
-     */
-    LLDependenciesEmpty(void*) {}    
-};
-
-/**
- * This class manages abstract dependencies between node types of your
- * choosing. As with a std::map, nodes are copied when add()ed, so the node
- * type should be relatively lightweight; to manipulate dependencies between
- * expensive objects, use a pointer type.
- *
- * For a given node, you may state the keys of nodes that must precede it
- * and/or nodes that must follow it. The sort() method will produce an order
- * that should work, or throw an exception if the constraints are impossible.
- * We cache results to minimize the cost of repeated sort() calls.
- */
-template<typename KEY = std::string,
-         typename NODE = LLDependenciesEmpty>
-class LLDependencies: public LLDependenciesBase
-{
-    typedef LLDependencies<KEY, NODE> self_type;
-
-    /**
-     * Internally, we bundle the client's NODE with its before/after keys.
-     */
-    struct DepNode
-    {
-        typedef std::set<KEY> dep_set;
-        DepNode(const NODE& node_, const dep_set& after_, const dep_set& before_):
-            node(node_),
-            after(after_),
-            before(before_)
-        {}
-        NODE node;
-        dep_set after, before;    
-    };
-    typedef std::map<KEY, DepNode> DepNodeMap;
-    typedef typename DepNodeMap::value_type DepNodeMapEntry;
-
-    /// We have various ways to get the dependencies for a given DepNode.
-    /// Rather than having to restate each one for 'after' and 'before'
-    /// separately, pass a dep_selector so we can apply each to either.
-    typedef boost::function<const typename DepNode::dep_set&(const DepNode&)> dep_selector;
-
-public:
-    LLDependencies() {}
-
-    typedef KEY key_type;
-    typedef NODE node_type;
-
-    /// param type used to express lists of other node keys -- note that such
-    /// lists can be initialized with boost::assign::list_of()
-    typedef std::vector<KEY> KeyList;
-
-    /**
-     * Add a new node. State its dependencies on other nodes (which may not
-     * yet have been added) by listing the keys of nodes this new one must
-     * follow, and separately the keys of nodes this new one must precede.
-     *
-     * The node you pass is @em copied into an internal data structure. If you
-     * want to modify the node value after add()ing it, capture the returned
-     * NODE& reference.
-     *
-     * @note
-     * Actual dependency analysis is deferred to the sort() method, so 
-     * you can add an arbitrary number of nodes without incurring analysis
-     * overhead for each. The flip side of this is that add()ing nodes that
-     * define a cycle leaves this object in a state in which sort() will
-     * always throw the Cycle exception.
-     *
-     * Two distinct use cases are anticipated:
-     * * The data used to load this object are completely known at compile
-     * time (e.g. LLEventPump listener names). A Cycle exception represents a
-     * bug which can be corrected by the coder. The program need neither catch
-     * Cycle nor attempt to salvage the state of this object.
-     * * The data are loaded at runtime, therefore the universe of
-     * dependencies cannot be known at compile time. The client code should
-     * catch Cycle.
-     * ** If a Cycle exception indicates fatally-flawed input data, this
-     * object can simply be discarded, possibly with the entire program run.
-     * ** If it is essential to restore this object to a working state, the
-     * simplest workaround is to remove() nodes in LIFO order.
-     * *** It may be useful to add functionality to this class to track the
-     * add() chronology, providing a pop() method to remove the most recently
-     * added node.
-     * *** It may further be useful to add a restore() method which would
-     * pop() until sort() no longer throws Cycle. This method would be
-     * expensive -- but it's not clear that client code could resolve the
-     * problem more cheaply.
-     */
-    NODE& add(const KEY& key, const NODE& node = NODE(),
-              const KeyList& after = KeyList(),
-              const KeyList& before = KeyList())
-    {
-        // Get the passed-in lists as sets for equality comparison
-        typename DepNode::dep_set
-            after_set(after.begin(), after.end()),
-            before_set(before.begin(), before.end());
-        // Try to insert the new node; if it already exists, find the old
-        // node instead.
-        std::pair<typename DepNodeMap::iterator, bool> inserted =
-            mNodes.insert(typename DepNodeMap::value_type(key,
-                                                          DepNode(node, after_set, before_set)));
-        if (! inserted.second)      // bool indicating success of insert()
-        {
-            // We already have a node by this name. Have its dependencies
-            // changed? If the existing node's dependencies are identical, the
-            // result will be unchanged, so we can leave the cache intact.
-            // Regardless of inserted.second, inserted.first is the iterator
-            // to the newly-inserted (or existing) map entry. Of course, that
-            // entry's second is the DepNode of interest.
-            if (inserted.first->second.after  != after_set ||
-                inserted.first->second.before != before_set)
-            {
-                // Dependencies have changed: clear the cached result.
-                mCache.clear();
-                // save the new dependencies
-                inserted.first->second.after  = after_set;
-                inserted.first->second.before = before_set;
-            }
-        }
-        else                        // this node is new
-        {
-            // This will change results.
-            mCache.clear();
-        }
-        return inserted.first->second.node;
-    }
-
-    /// the value of an iterator, showing both KEY and its NODE
-    typedef refpair<const KEY&, NODE&> value_type;
-    /// the value of a const_iterator
-    typedef refpair<const KEY&, const NODE&> const_value_type;
-
-private:
-    // Extract functors
-    static value_type value_extract(DepNodeMapEntry& entry)
-    {
-        return value_type(entry.first, entry.second.node);
-    }
-
-    static const_value_type const_value_extract(const DepNodeMapEntry& entry)
-    {
-        return const_value_type(entry.first, entry.second.node);
-    }
-
-    // All the iterator access methods return iterator ranges just to cut down
-    // on the friggin' boilerplate!!
-
-    /// generic mNodes range method
-    template<typename ITERATOR, typename FUNCTION>
-    boost::iterator_range<ITERATOR> generic_range(FUNCTION function)
-    {
-        return make_transform_range(mNodes, function);
-    }
-
-    /// generic mNodes const range method
-    template<typename ITERATOR, typename FUNCTION>
-    boost::iterator_range<ITERATOR> generic_range(FUNCTION function) const
-    {
-        return make_transform_range(mNodes, function);
-    }
-
-public:
-    /// iterator over value_type entries
-    typedef boost::transform_iterator<boost::function<value_type(DepNodeMapEntry&)>,
-                                      typename DepNodeMap::iterator> iterator;
-    /// range over value_type entries
-    typedef boost::iterator_range<iterator> range;
-
-    /// iterate over value_type <i>in @c KEY order</i> rather than dependency order
-    range get_range()
-    {
-        return generic_range<iterator>(value_extract);
-    }
-
-    /// iterator over const_value_type entries
-    typedef boost::transform_iterator<boost::function<const_value_type(const DepNodeMapEntry&)>,
-                                      typename DepNodeMap::const_iterator> const_iterator;
-    /// range over const_value_type entries
-    typedef boost::iterator_range<const_iterator> const_range;
-
-    /// iterate over const_value_type <i>in @c KEY order</i> rather than dependency order
-    const_range get_range() const
-    {
-        return generic_range<const_iterator>(const_value_extract);
-    }
-
-    /// iterator over stored NODEs
-    typedef boost::transform_iterator<boost::function<NODE&(DepNodeMapEntry&)>,
-                                      typename DepNodeMap::iterator> node_iterator;
-    /// range over stored NODEs
-    typedef boost::iterator_range<node_iterator> node_range;
-
-    /// iterate over NODE <i>in @c KEY order</i> rather than dependency order
-    node_range get_node_range()
-    {
-        // First take a DepNodeMapEntry and extract a reference to its
-        // DepNode, then from that extract a reference to its NODE.
-        return generic_range<node_iterator>(
-            boost::bind<NODE&>(&DepNode::node,
-                               boost::bind<DepNode&>(&DepNodeMapEntry::second, _1)));
-    }
-
-    /// const iterator over stored NODEs
-    typedef boost::transform_iterator<boost::function<const NODE&(const DepNodeMapEntry&)>,
-                                      typename DepNodeMap::const_iterator> const_node_iterator;
-    /// const range over stored NODEs
-    typedef boost::iterator_range<const_node_iterator> const_node_range;
-
-    /// iterate over const NODE <i>in @c KEY order</i> rather than dependency order
-    const_node_range get_node_range() const
-    {
-        // First take a DepNodeMapEntry and extract a reference to its
-        // DepNode, then from that extract a reference to its NODE.
-        return generic_range<const_node_iterator>(
-            boost::bind<const NODE&>(&DepNode::node,
-                                     boost::bind<const DepNode&>(&DepNodeMapEntry::second, _1)));
-    }
-
-    /// const iterator over stored KEYs
-    typedef boost::transform_iterator<boost::function<const KEY&(const DepNodeMapEntry&)>,
-                                      typename DepNodeMap::const_iterator> const_key_iterator;
-    /// const range over stored KEYs
-    typedef boost::iterator_range<const_key_iterator> const_key_range;
-    // We don't provide a non-const iterator over KEYs because they should be
-    // immutable, and in fact our underlying std::map won't give us non-const
-    // references.
-
-    /// iterate over const KEY <i>in @c KEY order</i> rather than dependency order
-    const_key_range get_key_range() const
-    {
-        // From a DepNodeMapEntry, extract a reference to its KEY.
-        return generic_range<const_key_iterator>(
-            boost::bind<const KEY&>(&DepNodeMapEntry::first, _1));
-    }
-
-    /**
-     * Find an existing NODE, or return NULL. We decided to avoid providing a
-     * method analogous to std::map::find(), for a couple of reasons:
-     *
-     * * For a find-by-key, getting back an iterator to the (key, value) pair
-     * is less than useful, since you already have the key in hand.
-     * * For a failed request, comparing to end() is problematic. First, we
-     * provide range accessors, so it's more code to get end(). Second, we
-     * provide a number of different ranges -- quick, to which one's end()
-     * should we compare the iterator returned by find()?
-     *
-     * The returned pointer is solely to allow expressing the not-found
-     * condition. LLDependencies still owns the found NODE.
-     */
-    const NODE* get(const KEY& key) const
-    {
-        typename DepNodeMap::const_iterator found = mNodes.find(key);
-        if (found != mNodes.end())
-        {
-            return &found->second.node;
-        }
-        return NULL;
-    }
-
-    /**
-     * non-const get()
-     */
-    NODE* get(const KEY& key)
-    {
-        // Use const implementation, then cast away const-ness of return
-        return const_cast<NODE*>(const_cast<const self_type*>(this)->get(key));
-    }
-
-    /**
-     * Remove a node with specified key. This operation is the major reason
-     * we rebuild the graph on the fly instead of storing it.
-     */
-    bool remove(const KEY& key)
-    {
-        typename DepNodeMap::iterator found = mNodes.find(key);
-        if (found != mNodes.end())
-        {
-            mNodes.erase(found);
-            return true;
-        }
-        return false;
-    }
-
-private:
-    /// cached list of iterators
-    typedef std::vector<iterator> iterator_list;
-    typedef typename iterator_list::iterator iterator_list_iterator;
-
-public:
-    /**
-     * The return type of the sort() method needs some explanation. Provide a
-     * public typedef to facilitate storing the result.
-     *
-     * * We will prepare mCache by looking up DepNodeMap iterators.
-     * * We want to return a range containing iterators that will walk mCache.
-     * * If we simply stored DepNodeMap iterators and returned
-     * (mCache.begin(), mCache.end()), dereferencing each iterator would
-     * obtain a DepNodeMap iterator.
-     * * We want the caller to loop over @c value_type: pair<KEY, NODE>.
-     * * This requires two transformations:
-     * ** mCache must contain @c LLDependencies::iterator so that
-     * dereferencing each entry will obtain an @c LLDependencies::value_type
-     * rather than a DepNodeMapEntry.
-     * ** We must wrap mCache's iterators in boost::indirect_iterator so that
-     * dereferencing one of our returned iterators will also dereference the
-     * iterator contained in mCache.
-     */
-    typedef boost::iterator_range<boost::indirect_iterator<iterator_list_iterator> > sorted_range;
-    /// for convenience in looping over a sorted_range
-    typedef typename sorted_range::iterator sorted_iterator;
-
-    /**
-     * Once we've loaded in the dependencies of interest, arrange them into an
-     * order that works -- or throw Cycle exception.
-     *
-     * Return an iterator range over (key, node) pairs that traverses them in
-     * the desired order.
-     */
-    sorted_range sort() const
-    {
-        // Changes to mNodes cause us to clear our cache, so empty mCache
-        // means it's invalid and should be recomputed. However, if mNodes is
-        // also empty, then an empty mCache represents a valid order, so don't
-        // bother sorting.
-        if (mCache.empty() && ! mNodes.empty())
-        {
-            // Construct a map of node keys to distinct vertex numbers -- even for
-            // nodes mentioned only in before/after constraints, that haven't yet
-            // been explicitly added. Rely on std::map rejecting a second attempt
-            // to insert the same key. Use the map's size() as the vertex number
-            // to get a distinct value for each successful insertion.
-            typedef std::map<KEY, int> VertexMap;
-            VertexMap vmap;
-            // Nest each of these loops because !@#$%? MSVC warns us that its
-            // former broken behavior has finally been fixed -- and our builds
-            // treat warnings as errors.
-            {
-                for (typename DepNodeMap::const_iterator nmi = mNodes.begin(), nmend = mNodes.end();
-                     nmi != nmend; ++nmi)
-                {
-                    vmap.insert(typename VertexMap::value_type(nmi->first, vmap.size()));
-                    for (typename DepNode::dep_set::const_iterator ai = nmi->second.after.begin(),
-                                                                   aend = nmi->second.after.end();
-                         ai != aend; ++ai)
-                    {
-                        vmap.insert(typename VertexMap::value_type(*ai, vmap.size()));
-                    }
-                    for (typename DepNode::dep_set::const_iterator bi = nmi->second.before.begin(),
-                                                                   bend = nmi->second.before.end();
-                         bi != bend; ++bi)
-                    {
-                        vmap.insert(typename VertexMap::value_type(*bi, vmap.size()));
-                    }
-                }
-            }
-            // Define the edges. For this we must traverse mNodes again, mapping
-            // all the known key dependencies to integer pairs.
-            EdgeList edges;
-            {
-                for (typename DepNodeMap::const_iterator nmi = mNodes.begin(), nmend = mNodes.end();
-                     nmi != nmend; ++nmi)
-                {
-                    int thisnode = vmap[nmi->first];
-                    // after dependencies: build edges from the named node to this one
-                    for (typename DepNode::dep_set::const_iterator ai = nmi->second.after.begin(),
-                                                                   aend = nmi->second.after.end();
-                         ai != aend; ++ai)
-                    {
-                        edges.push_back(EdgeList::value_type(vmap[*ai], thisnode));
-                    }
-                    // before dependencies: build edges from this node to the
-                    // named one
-                    for (typename DepNode::dep_set::const_iterator bi = nmi->second.before.begin(),
-                                                                   bend = nmi->second.before.end();
-                         bi != bend; ++bi)
-                    {
-                        edges.push_back(EdgeList::value_type(thisnode, vmap[*bi]));
-                    }
-                }
-            }
-            // Hide the gory details of our topological sort, since they shouldn't
-            // get reinstantiated for each distinct NODE type.
-            VertexList sorted(topo_sort(vmap.size(), edges));
-            // Build the reverse of vmap to look up the key for each vertex
-            // descriptor. vmap contains exactly one entry for each distinct key,
-            // and we're certain that the associated int values are distinct
-            // indexes. The fact that they're not in order is irrelevant.
-            KeyList vkeys(vmap.size());
-            for (typename VertexMap::const_iterator vmi = vmap.begin(), vmend = vmap.end();
-                 vmi != vmend; ++vmi)
-            {
-                vkeys[vmi->second] = vmi->first;
-            }
-            // Walk the sorted output list, building the result into mCache so
-            // we'll have it next time someone asks.
-            mCache.clear();
-            for (VertexList::const_iterator svi = sorted.begin(), svend = sorted.end();
-                 svi != svend; ++svi)
-            {
-                // We're certain that vkeys[*svi] exists. However, there might not
-                // yet be a corresponding entry in mNodes.
-                self_type* non_const_this(const_cast<self_type*>(this));
-                typename DepNodeMap::iterator found = non_const_this->mNodes.find(vkeys[*svi]);
-                if (found != non_const_this->mNodes.end())
-                {
-                    // Make an iterator of appropriate type.
-                    mCache.push_back(iterator(found, value_extract));
-                }
-            }
-        }
-        // Whether or not we've just recomputed mCache, it should now contain
-        // the results we want. Return a range of indirect_iterators over it
-        // so that dereferencing a returned iterator will dereference the
-        // iterator stored in mCache and directly reference the (key, node)
-        // pair.
-        boost::indirect_iterator<iterator_list_iterator>
-            begin(mCache.begin()),
-            end(mCache.end());
-        return sorted_range(begin, end);
-    }
-
-	using LLDependenciesBase::describe; // unhide virtual std::string describe(bool full=true) const;
-
-    /// Override base-class describe() with actual implementation
-    virtual std::ostream& describe(std::ostream& out, bool full=true) const
-    {
-        typename DepNodeMap::const_iterator dmi(mNodes.begin()), dmend(mNodes.end());
-        if (dmi != dmend)
-        {
-            std::string sep;
-            describe(out, sep, *dmi, full);
-            while (++dmi != dmend)
-            {
-                describe(out, sep, *dmi, full);
-            }
-        }
-        return out;
-    }
-
-
-    /// describe() helper: report a DepNodeEntry
-    static std::ostream& describe(std::ostream& out, std::string& sep,
-                                  const DepNodeMapEntry& entry, bool full)
-    {
-        // If we were asked for a full report, describe every node regardless
-        // of whether it has dependencies. If we were asked to suppress
-        // independent nodes, describe this one if either after or before is
-        // non-empty.
-        if (full || (! entry.second.after.empty()) || (! entry.second.before.empty()))
-        {
-            out << sep;
-            sep = "\n";
-            if (! entry.second.after.empty())
-            {
-                out << "after ";
-                describe(out, entry.second.after);
-                out << " -> ";
-            }
-            LLDependencies_describe(out, entry.first);
-            if (! entry.second.before.empty())
-            {
-                out << " -> before ";
-                describe(out, entry.second.before);
-            }
-        }
-        return out;
-    }
-
-    /// describe() helper: report a dep_set
-    static std::ostream& describe(std::ostream& out, const typename DepNode::dep_set& keys)
-    {
-        out << '(';
-        typename DepNode::dep_set::const_iterator ki(keys.begin()), kend(keys.end());
-        if (ki != kend)
-        {
-            LLDependencies_describe(out, *ki);
-            while (++ki != kend)
-            {
-                out << ", ";
-                LLDependencies_describe(out, *ki);
-            }
-        }
-        out << ')';
-        return out;
-    }
-
-    /// Iterator over the before/after KEYs on which a given NODE depends
-    typedef typename DepNode::dep_set::const_iterator dep_iterator;
-    /// range over the before/after KEYs on which a given NODE depends
-    typedef boost::iterator_range<dep_iterator> dep_range;
-
-    /// dependencies access from key
-    dep_range get_dep_range_from_key(const KEY& key, const dep_selector& selector) const
-    {
-        typename DepNodeMap::const_iterator found = mNodes.find(key);
-        if (found != mNodes.end())
-        {
-            return dep_range(selector(found->second));
-        }
-        // We want to return an empty range. On some platforms a default-
-        // constructed range (e.g. dep_range()) does NOT suffice! The client
-        // is likely to try to iterate from boost::begin(range) to
-        // boost::end(range); yet these iterators might not be valid. Instead
-        // return a range over a valid, empty container.
-        static const typename DepNode::dep_set empty_deps;
-        return dep_range(empty_deps.begin(), empty_deps.end());
-    }
-
-    /// dependencies access from any one of our key-order iterators
-    template<typename ITERATOR>
-    dep_range get_dep_range_from_xform(const ITERATOR& iterator, const dep_selector& selector) const
-    {
-        return dep_range(selector(iterator.base()->second));
-    }
-
-    /// dependencies access from sorted_iterator
-    dep_range get_dep_range_from_sorted(const sorted_iterator& sortiter,
-                                        const dep_selector& selector) const
-    {
-        // sorted_iterator is a boost::indirect_iterator wrapping an mCache
-        // iterator, which we can obtain by sortiter.base(). Deferencing that
-        // gets us an mCache entry, an 'iterator' -- one of our traversal
-        // iterators -- on which we can use get_dep_range_from_xform().
-        return get_dep_range_from_xform(*sortiter.base(), selector);
-    }
-
-    /**
-     * Get a range over the after KEYs stored for the passed KEY or iterator,
-     * in <i>arbitrary order.</i> If you pass a nonexistent KEY, returns empty
-     * range -- same as a KEY with no after KEYs. Detect existence of a KEY
-     * using get() instead.
-     */
-    template<typename KEY_OR_ITER>
-    dep_range get_after_range(const KEY_OR_ITER& key) const;
-
-    /**
-     * Get a range over the before KEYs stored for the passed KEY or iterator,
-     * in <i>arbitrary order.</i> If you pass a nonexistent KEY, returns empty
-     * range -- same as a KEY with no before KEYs. Detect existence of a KEY
-     * using get() instead.
-     */
-    template<typename KEY_OR_ITER>
-    dep_range get_before_range(const KEY_OR_ITER& key) const;
-
-private:
-    DepNodeMap mNodes;
-    mutable iterator_list mCache;
-};
-
-/**
- * Functor to get a dep_range from a KEY or iterator -- generic case. If the
- * passed value isn't one of our iterator specializations, assume it's
- * convertible to the KEY type.
- */
-template<typename KEY_ITER>
-struct LLDependencies_dep_range_from
-{
-    template<typename KEY, typename NODE, typename SELECTOR>
-    typename LLDependencies<KEY, NODE>::dep_range
-    operator()(const LLDependencies<KEY, NODE>& deps,
-               const KEY_ITER& key,
-               const SELECTOR& selector)
-    {
-        return deps.get_dep_range_from_key(key, selector);
-    }
-};
-
-/// Specialize LLDependencies_dep_range_from for our key-order iterators
-template<typename FUNCTION, typename ITERATOR>
-struct LLDependencies_dep_range_from< boost::transform_iterator<FUNCTION, ITERATOR> >
-{
-    template<typename KEY, typename NODE, typename SELECTOR>
-    typename LLDependencies<KEY, NODE>::dep_range
-    operator()(const LLDependencies<KEY, NODE>& deps,
-               const boost::transform_iterator<FUNCTION, ITERATOR>& iter,
-               const SELECTOR& selector)
-    {
-        return deps.get_dep_range_from_xform(iter, selector);
-    }
-};
-
-/// Specialize LLDependencies_dep_range_from for sorted_iterator
-template<typename BASEITER>
-struct LLDependencies_dep_range_from< boost::indirect_iterator<BASEITER> >
-{
-    template<typename KEY, typename NODE, typename SELECTOR>
-    typename LLDependencies<KEY, NODE>::dep_range
-    operator()(const LLDependencies<KEY, NODE>& deps,
-               const boost::indirect_iterator<BASEITER>& iter,
-               const SELECTOR& selector)
-    {
-        return deps.get_dep_range_from_sorted(iter, selector);
-    }
-};
-
-/// generic get_after_range() implementation
-template<typename KEY, typename NODE>
-template<typename KEY_OR_ITER>
-typename LLDependencies<KEY, NODE>::dep_range
-LLDependencies<KEY, NODE>::get_after_range(const KEY_OR_ITER& key_iter) const
-{
-    return LLDependencies_dep_range_from<KEY_OR_ITER>()(
-        *this,
-        key_iter,
-        boost::bind<const typename DepNode::dep_set&>(&DepNode::after, _1));
-}
-
-/// generic get_before_range() implementation
-template<typename KEY, typename NODE>
-template<typename KEY_OR_ITER>
-typename LLDependencies<KEY, NODE>::dep_range
-LLDependencies<KEY, NODE>::get_before_range(const KEY_OR_ITER& key_iter) const
-{
-    return LLDependencies_dep_range_from<KEY_OR_ITER>()(
-        *this,
-        key_iter,
-        boost::bind<const typename DepNode::dep_set&>(&DepNode::before, _1));
-}
-
-#endif /* ! defined(LL_LLDEPENDENCIES_H) */

indra/llcommon/llerror.cpp

@@ -402,7 +402,7 @@ namespace
 	{
 		/* This pattern, of returning a reference to a static function
 		   variable, is to ensure that this global is constructed before
-		   it is used, no matter what the global initialization sequence
+		   it is used, no matter what the global initializeation sequence
 		   is.
 		   See C++ FAQ Lite, sections 10.12 through 10.14
 		*/

indra/llcommon/llerror.h

@@ -45,7 +45,7 @@
 
 	Information for most users:
 	
-	Code can log messages with constructions like this:
+	Code can log messages with constuctions like this:
 	
 		LL_INFOS("StringTag") << "request to fizzbip agent " << agent_id
 			<< " denied due to timeout" << LL_ENDL;
@@ -53,9 +53,9 @@
 	Messages can be logged to one of four increasing levels of concern,
 	using one of four "streams":
 
-		LL_DEBUGS("StringTag")	- debug messages that are normally suppressed
-		LL_INFOS("StringTag")	- informational messages that are normally shown
-		LL_WARNS("StringTag")	- warning messages that signal a problem
+		LL_DEBUGS("StringTag")	- debug messages that are normally supressed
+		LL_INFOS("StringTag")	- informational messages that are normall shown
+		LL_WARNS("StringTag")	- warning messages that singal a problem
 		LL_ERRS("StringTag")	- error messages that are major, unrecoverable failures
 		
 	The later (LL_ERRS("StringTag")) automatically crashes the process after the message
@@ -96,7 +96,7 @@
 	
 		WARN: LLFoo::doSomething: called with a big value for i: 283
 	
-	Which messages are logged and which are suppressed can be controlled at run
+	Which messages are logged and which are supressed can be controled at run
 	time from the live file logcontrol.xml based on function, class and/or 
 	source file.  See etc/logcontrol-dev.xml for details.
 	
@@ -112,7 +112,7 @@ namespace LLError
 	enum ELevel
 	{
 		LEVEL_ALL = 0,
-			// used to indicate that all messages should be logged
+			// used to indicate that all messagess should be logged
 			
 		LEVEL_DEBUG = 0,
 		LEVEL_INFO = 1,
@@ -226,7 +226,7 @@ namespace LLError
 	// See top of file for example of how to use this
 	
 typedef LLError::NoClassInfo _LL_CLASS_TO_LOG;
-	// Outside a class declaration, or in class without LOG_CLASS(), this
+	// Outside a class declartion, or in class without LOG_CLASS(), this
 	// typedef causes the messages to not be associated with any class.
 
 

indra/llcommon/llerrorlegacy.h

@@ -107,14 +107,7 @@ const int LL_ERR_PRICE_MISMATCH = -23018;
 
 #define llwarning(msg, num)		llwarns << "Warning # " << num << ": " << msg << llendl;
 
-#define liru_slashpos			std::string(__FILE__).find_last_of("/\\")
-#define liru_slashpos2			std::string(__FILE__).substr(0,liru_slashpos).find_last_of("/\\")
-#define liru_assert_strip		/*strip path down to lastlevel directory and filename for assert.*/\
-	(liru_slashpos == std::string::npos ? std::string(__FILE__)/*just filename, print as is*/\
-		: liru_slashpos2 == std::string::npos ? std::string(__FILE__)/*Apparently, we're in / or perhaps the top of the drive, print as is*/\
-			: std::string(__FILE__).substr(1+liru_slashpos2))/*print foo/bar.cpp or perhaps foo\bar.cpp*/
-
-#define llassert_always(func)		if (LL_UNLIKELY(!(func))) llerrs <<"\nASSERT(" #func ")\nfile:"<<liru_assert_strip<<" line:"<<__LINE__ << llendl;
+#define llassert_always(func)	if (LL_UNLIKELY(!(func))) llerrs << "ASSERT (" << #func << ")" << llendl;
 
 #ifdef SHOW_ASSERT
 #define llassert(func)			llassert_always(func)

indra/llcommon/llerrorthread.cpp

@@ -31,7 +31,6 @@
 
 #include "linden_common.h"
 #include "llerrorthread.h"
-
 #include "llapp.h"
 #include "lltimer.h"	// ms_sleep()
 
@@ -118,8 +117,13 @@ void LLErrorThread::run()
 #if !LL_WINDOWS
 	U32 last_sig_child_count = 0;
 #endif
-	while (! (LLApp::isError() || LLApp::isStopped()))
+	while (1)
 	{
+		if (LLApp::isError() || LLApp::isStopped())
+		{
+			// The application has stopped running, time to take action (maybe)
+			break;
+		}
 #if !LL_WINDOWS
 		// Check whether or not the main thread had a sig child we haven't handled.
 		U32 current_sig_child_count = LLApp::getSigChildCount();

indra/llcommon/llevent.cpp

@@ -34,8 +34,6 @@
 
 #include "llevent.h"
 
-using namespace LLOldEvents;
-
 /************************************************
     Events
 ************************************************/

indra/llcommon/llevent.h

@@ -35,12 +35,9 @@
 #define LL_EVENT_H
 
 #include "llsd.h"
-#include "llpointer.h"
+#include "llmemory.h"
 #include "llthread.h"
 
-namespace LLOldEvents
-{
-
 class LLEventListener;
 class LLEvent;
 class LLEventDispatcher;
@@ -197,6 +194,4 @@ public:
 	LLSD mValue;
 };
 
-} // LLOldEvents
-
 #endif // LL_EVENT_H

indra/llcommon/lleventapi.cpp

@@ -1,77 +0,0 @@
-/**
- * @file   lleventapi.cpp
- * @author Nat Goodspeed
- * @date   2009-11-10
- * @brief  Implementation for lleventapi.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-#include "lleventapi.h"
-// STL headers
-// std headers
-// external library headers
-// other Linden headers
-#include "llerror.h"
-
-LLEventAPI::LLEventAPI(const std::string& name, const std::string& desc, const std::string& field):
-    lbase(name, field),
-    ibase(name),
-    mDesc(desc)
-{
-}
-
-LLEventAPI::~LLEventAPI()
-{
-}
-
-LLEventAPI::Response::Response(const LLSD& seed, const LLSD& request, const LLSD::String& replyKey):
-    mResp(seed),
-    mReq(request),
-    mKey(replyKey)
-{}
-
-LLEventAPI::Response::~Response()
-{
-    // When you instantiate a stack Response object, if the original
-    // request requested a reply, send it when we leave this block, no
-    // matter how.
-    sendReply(mResp, mReq, mKey);
-}
-
-void LLEventAPI::Response::warn(const std::string& warning)
-{
-    LL_WARNS("LLEventAPI::Response") << warning << LL_ENDL;
-    mResp["warnings"].append(warning);
-}
-
-void LLEventAPI::Response::error(const std::string& error)
-{
-    // Use LL_WARNS rather than LL_ERROR: we don't want the viewer to shut
-    // down altogether.
-    LL_WARNS("LLEventAPI::Response") << error << LL_ENDL;
-
-    mResp["error"] = error;
-}

indra/llcommon/lleventapi.h

@@ -1,166 +0,0 @@
-/**
- * @file   lleventapi.h
- * @author Nat Goodspeed
- * @date   2009-10-28
- * @brief  LLEventAPI is the base class for every class that wraps a C++ API
- *         in an event API
- * (see https://wiki.lindenlab.com/wiki/Incremental_Viewer_Automation/Event_API).
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if ! defined(LL_LLEVENTAPI_H)
-#define LL_LLEVENTAPI_H
-
-#include "lleventdispatcher.h"
-#include "llinstancetracker.h"
-#include <string>
-
-/**
- * LLEventAPI not only provides operation dispatch functionality, inherited
- * from LLDispatchListener -- it also gives us event API introspection.
- * Deriving from LLInstanceTracker lets us enumerate instances.
- */
-class LL_COMMON_API LLEventAPI: public LLDispatchListener,
-                  public LLInstanceTracker<LLEventAPI, std::string>
-{
-    typedef LLDispatchListener lbase;
-    typedef LLInstanceTracker<LLEventAPI, std::string> ibase;
-
-public:
-    /**
-     * @param name LLEventPump name on which this LLEventAPI will listen. This
-     * also serves as the LLInstanceTracker instance key.
-     * @param desc Documentation string shown to a client trying to discover
-     * available event APIs.
-     * @param field LLSD::Map key used by LLDispatchListener to look up the
-     * subclass method to invoke [default "op"].
-     */
-    LLEventAPI(const std::string& name, const std::string& desc, const std::string& field="op");
-    virtual ~LLEventAPI();
-
-    /// Get the string name of this LLEventAPI
-    std::string getName() const { return ibase::getKey(); }
-    /// Get the documentation string
-    std::string getDesc() const { return mDesc; }
-
-    /**
-     * Publish only selected add() methods from LLEventDispatcher.
-     * Every LLEventAPI add() @em must have a description string.
-     */
-    template <typename CALLABLE>
-    void add(const std::string& name,
-             const std::string& desc,
-             CALLABLE callable,
-             const LLSD& required=LLSD())
-    {
-        LLEventDispatcher::add(name, desc, callable, required);
-    }
-
-    /**
-     * Instantiate a Response object in any LLEventAPI subclass method that
-     * wants to guarantee a reply (if requested) will be sent on exit from the
-     * method. The reply will be sent if request.has(@a replyKey), default
-     * "reply". If specified, the value of request[replyKey] is the name of
-     * the LLEventPump on which to send the reply. Conventionally you might
-     * code something like:
-     *
-     * @code
-     * void MyEventAPI::someMethod(const LLSD& request)
-     * {
-     *     // Send a reply event as long as request.has("reply")
-     *     Response response(LLSD(), request);
-     *     // ...
-     *     // will be sent in reply event
-     *     response["somekey"] = some_data;
-     * }
-     * @endcode
-     */
-    class LL_COMMON_API Response
-    {
-    public:
-        /**
-         * Instantiating a Response object in an LLEventAPI subclass method
-         * ensures that, if desired, a reply event will be sent.
-         *
-         * @a seed is the initial reply LLSD that will be further decorated before
-         * being sent as the reply
-         *
-         * @a request is the incoming request LLSD; we particularly care about
-         * [replyKey] and ["reqid"]
-         *
-         * @a replyKey [default "reply"] is the string name of the LLEventPump
-         * on which the caller wants a reply. If <tt>(!
-         * request.has(replyKey))</tt>, no reply will be sent.
-         */
-        Response(const LLSD& seed, const LLSD& request, const LLSD::String& replyKey="reply");
-        ~Response();
-
-        /**
-         * @code
-         * if (some condition)
-         * {
-         *     response.warn("warnings are logged and collected in [\"warnings\"]");
-         * }
-         * @endcode
-         */
-        void warn(const std::string& warning);
-        /**
-         * @code
-         * if (some condition isn't met)
-         * {
-         *     // In a function returning void, you can validly 'return
-         *     // expression' if the expression is itself of type void. But
-         *     // returning is up to you; response.error() has no effect on
-         *     // flow of control.
-         *     return response.error("error message, logged and also sent as [\"error\"]");
-         * }
-         * @endcode
-         */
-        void error(const std::string& error);
-
-        /**
-         * set other keys...
-         *
-         * @code
-         * // set any attributes you want to be sent in the reply
-         * response["info"] = some_value;
-         * // ...
-         * response["ok"] = went_well;
-         * @endcode
-         */
-        LLSD& operator[](const LLSD::String& key) { return mResp[key]; }
-		
-		 /**
-		 * set the response to the given data
-		 */
-		void setResponse(LLSD const & response){ mResp = response; }
-
-        LLSD mResp, mReq;
-        LLSD::String mKey;
-    };
-
-private:
-    std::string mDesc;
-};
-
-#endif /* ! defined(LL_LLEVENTAPI_H) */

indra/llcommon/lleventcoro.cpp

@@ -1,146 +0,0 @@
-/**
- * @file   lleventcoro.cpp
- * @author Nat Goodspeed
- * @date   2009-04-29
- * @brief  Implementation for lleventcoro.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-#include "lleventcoro.h"
-// STL headers
-#include <map>
-// std headers
-// external library headers
-// other Linden headers
-#include "llsdserialize.h"
-#include "llerror.h"
-#include "llcoros.h"
-
-std::string LLEventDetail::listenerNameForCoroImpl(const void* self_id)
-{
-    // First, if this coroutine was launched by LLCoros::launch(), find that name.
-    std::string name(LLCoros::instance().getNameByID(self_id));
-    if (! name.empty())
-    {
-        return name;
-    }
-    // Apparently this coroutine wasn't launched by LLCoros::launch(). Check
-    // whether we have a memo for this self_id.
-    typedef std::map<const void*, std::string> MapType;
-    static MapType memo;
-    MapType::const_iterator found = memo.find(self_id);
-    if (found != memo.end())
-    {
-        // this coroutine instance has called us before, reuse same name
-        return found->second;
-    }
-    // this is the first time we've been called for this coroutine instance
-    name = LLEventPump::inventName("coro");
-    memo[self_id] = name;
-    LL_INFOS("LLEventCoro") << "listenerNameForCoroImpl(" << self_id << "): inventing coro name '"
-                            << name << "'" << LL_ENDL;
-    return name;
-}
-
-void LLEventDetail::storeToLLSDPath(LLSD& dest, const LLSD& rawPath, const LLSD& value)
-{
-    if (rawPath.isUndefined())
-    {
-        // no-op case
-        return;
-    }
-
-    // Arrange to treat rawPath uniformly as an array. If it's not already an
-    // array, store it as the only entry in one.
-    LLSD path;
-    if (rawPath.isArray())
-    {
-        path = rawPath;
-    }
-    else
-    {
-        path.append(rawPath);
-    }
-
-    // Need to indicate a current destination -- but that current destination
-    // needs to change as we step through the path array. Where normally we'd
-    // use an LLSD& to capture a subscripted LLSD lvalue, this time we must
-    // instead use a pointer -- since it must be reassigned.
-    LLSD* pdest = &dest;
-
-    // Now loop through that array
-    for (LLSD::Integer i = 0; i < path.size(); ++i)
-    {
-        if (path[i].isString())
-        {
-            // *pdest is an LLSD map
-            pdest = &((*pdest)[path[i].asString()]);
-        }
-        else if (path[i].isInteger())
-        {
-            // *pdest is an LLSD array
-            pdest = &((*pdest)[path[i].asInteger()]);
-        }
-        else
-        {
-            // What do we do with Real or Array or Map or ...?
-            // As it's a coder error -- not a user error -- rub the coder's
-            // face in it so it gets fixed.
-            LL_ERRS("lleventcoro") << "storeToLLSDPath(" << dest << ", " << rawPath << ", " << value
-                                   << "): path[" << i << "] bad type " << path[i].type() << LL_ENDL;
-        }
-    }
-
-    // Here *pdest is where we should store value.
-    *pdest = value;
-}
-
-LLSD errorException(const LLEventWithID& result, const std::string& desc)
-{
-    // If the result arrived on the error pump (pump 1), instead of
-    // returning it, deliver it via exception.
-    if (result.second)
-    {
-        throw LLErrorEvent(desc, result.first);
-    }
-    // That way, our caller knows a simple return must be from the reply
-    // pump (pump 0).
-    return result.first;
-}
-
-LLSD errorLog(const LLEventWithID& result, const std::string& desc)
-{
-    // If the result arrived on the error pump (pump 1), log it as a fatal
-    // error.
-    if (result.second)
-    {
-        LL_ERRS("errorLog") << desc << ":" << std::endl;
-        LLSDSerialize::toPrettyXML(result.first, LL_CONT);
-        LL_CONT << LL_ENDL;
-    }
-    // A simple return must therefore be from the reply pump (pump 0).
-    return result.first;
-}

indra/llcommon/lleventcoro.h

@@ -1,569 +0,0 @@
-/**
- * @file   lleventcoro.h
- * @author Nat Goodspeed
- * @date   2009-04-29
- * @brief  Utilities to interface between coroutines and events.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if ! defined(LL_LLEVENTCORO_H)
-#define LL_LLEVENTCORO_H
-
-#include <boost/coroutine/coroutine.hpp>
-#include <boost/coroutine/future.hpp>
-#include <boost/optional.hpp>
-#include <string>
-#include <stdexcept>
-#include "llevents.h"
-#include "llerror.h"
-
-/**
- * Like LLListenerOrPumpName, this is a class intended for parameter lists:
- * accept a <tt>const LLEventPumpOrPumpName&</tt> and you can accept either an
- * <tt>LLEventPump&</tt> or its string name. For a single parameter that could
- * be either, it's not hard to overload the function -- but as soon as you
- * want to accept two such parameters, this is cheaper than four overloads.
- */
-class LLEventPumpOrPumpName
-{
-public:
-    /// Pass an actual LLEventPump&
-    LLEventPumpOrPumpName(LLEventPump& pump):
-        mPump(pump)
-    {}
-    /// Pass the string name of an LLEventPump
-    LLEventPumpOrPumpName(const std::string& pumpname):
-        mPump(LLEventPumps::instance().obtain(pumpname))
-    {}
-    /// Pass string constant name of an LLEventPump. This override must be
-    /// explicit, since otherwise passing <tt>const char*</tt> to a function
-    /// accepting <tt>const LLEventPumpOrPumpName&</tt> would require two
-    /// different implicit conversions: <tt>const char*</tt> -> <tt>const
-    /// std::string&</tt> -> <tt>const LLEventPumpOrPumpName&</tt>.
-    LLEventPumpOrPumpName(const char* pumpname):
-        mPump(LLEventPumps::instance().obtain(pumpname))
-    {}
-    /// Unspecified: "I choose not to identify an LLEventPump."
-    LLEventPumpOrPumpName() {}
-    operator LLEventPump& () const { return *mPump; }
-    LLEventPump& getPump() const { return *mPump; }
-    operator bool() const { return mPump; }
-    bool operator!() const { return ! mPump; }
-
-private:
-    boost::optional<LLEventPump&> mPump;
-};
-
-/// This is an adapter for a signature like void LISTENER(const LLSD&), which
-/// isn't a valid LLEventPump listener: such listeners should return bool.
-template <typename LISTENER>
-class LLVoidListener
-{
-public:
-    LLVoidListener(const LISTENER& listener):
-        mListener(listener)
-    {}
-    bool operator()(const LLSD& event)
-    {
-        mListener(event);
-        // don't swallow the event, let other listeners see it
-        return false;
-    }
-private:
-    LISTENER mListener;
-};
-
-/// LLVoidListener helper function to infer the type of the LISTENER
-template <typename LISTENER>
-LLVoidListener<LISTENER> voidlistener(const LISTENER& listener)
-{
-    return LLVoidListener<LISTENER>(listener);
-}
-
-namespace LLEventDetail
-{
-    /**
-     * waitForEventOn() permits a coroutine to temporarily listen on an
-     * LLEventPump any number of times. We don't really want to have to ask
-     * the caller to label each such call with a distinct string; the whole
-     * point of waitForEventOn() is to present a nice sequential interface to
-     * the underlying LLEventPump-with-named-listeners machinery. So we'll use
-     * LLEventPump::inventName() to generate a distinct name for each
-     * temporary listener. On the other hand, because a given coroutine might
-     * call waitForEventOn() any number of times, we don't really want to
-     * consume an arbitrary number of generated inventName()s: that namespace,
-     * though large, is nonetheless finite. So we memoize an invented name for
-     * each distinct coroutine instance (each different 'self' object). We
-     * can't know the type of 'self', because it depends on the coroutine
-     * body's signature. So we cast its address to void*, looking for distinct
-     * pointer values. Yes, that means that an early coroutine could cache a
-     * value here, then be destroyed, only to be supplanted by a later
-     * coroutine (of the same or different type), and we'll end up
-     * "recognizing" the second one and reusing the listener name -- but
-     * that's okay, since it won't collide with any listener name used by the
-     * earlier coroutine since that earlier coroutine no longer exists.
-     */
-    template <typename COROUTINE_SELF>
-    std::string listenerNameForCoro(COROUTINE_SELF& self)
-    {
-        return listenerNameForCoroImpl(self.get_id());
-    }
-
-    /// Implementation for listenerNameForCoro()
-    LL_COMMON_API std::string listenerNameForCoroImpl(const void* self_id);
-
-    /**
-     * Implement behavior described for postAndWait()'s @a replyPumpNamePath
-     * parameter:
-     *
-     * * If <tt>path.isUndefined()</tt>, do nothing.
-     * * If <tt>path.isString()</tt>, @a dest is an LLSD map: store @a value
-     *   into <tt>dest[path.asString()]</tt>.
-     * * If <tt>path.isInteger()</tt>, @a dest is an LLSD array: store @a
-     *   value into <tt>dest[path.asInteger()]</tt>.
-     * * If <tt>path.isArray()</tt>, iteratively apply the rules above to step
-     *   down through the structure of @a dest. The last array entry in @a
-     *   path specifies the entry in the lowest-level structure in @a dest
-     *   into which to store @a value.
-     *
-     * @note
-     * In the degenerate case in which @a path is an empty array, @a dest will
-     * @em become @a value rather than @em containing it.
-     */
-    LL_COMMON_API void storeToLLSDPath(LLSD& dest, const LLSD& path, const LLSD& value);
-} // namespace LLEventDetail
-
-/**
- * Post specified LLSD event on the specified LLEventPump, then wait for a
- * response on specified other LLEventPump. This is more than mere
- * convenience: the difference between this function and the sequence
- * @code
- * requestPump.post(myEvent);
- * LLSD reply = waitForEventOn(self, replyPump);
- * @endcode
- * is that the sequence above fails if the reply is posted immediately on
- * @a replyPump, that is, before <tt>requestPump.post()</tt> returns. In the
- * sequence above, the running coroutine isn't even listening on @a replyPump
- * until <tt>requestPump.post()</tt> returns and @c waitForEventOn() is
- * entered. Therefore, the coroutine completely misses an immediate reply
- * event, making it wait indefinitely.
- *
- * By contrast, postAndWait() listens on the @a replyPump @em before posting
- * the specified LLSD event on the specified @a requestPump.
- *
- * @param self The @c self object passed into a coroutine
- * @param event LLSD data to be posted on @a requestPump
- * @param requestPump an LLEventPump on which to post @a event. Pass either
- * the LLEventPump& or its string name. However, if you pass a
- * default-constructed @c LLEventPumpOrPumpName, we skip the post() call.
- * @param replyPump an LLEventPump on which postAndWait() will listen for a
- * reply. Pass either the LLEventPump& or its string name. The calling
- * coroutine will wait until that reply arrives. (If you're concerned about a
- * reply that might not arrive, please see also LLEventTimeout.)
- * @param replyPumpNamePath specifies the location within @a event in which to
- * store <tt>replyPump.getName()</tt>. This is a strictly optional convenience
- * feature; obviously you can store the name in @a event "by hand" if desired.
- * @a replyPumpNamePath can be specified in any of four forms:
- * * @c isUndefined() (default-constructed LLSD object): do nothing. This is
- *   the default behavior if you omit @a replyPumpNamePath.
- * * @c isInteger(): @a event is an array. Store <tt>replyPump.getName()</tt>
- *   in <tt>event[replyPumpNamePath.asInteger()]</tt>.
- * * @c isString(): @a event is a map. Store <tt>replyPump.getName()</tt> in
- *   <tt>event[replyPumpNamePath.asString()]</tt>.
- * * @c isArray(): @a event has several levels of structure, e.g. map of
- *   maps, array of arrays, array of maps, map of arrays, ... Store
- *   <tt>replyPump.getName()</tt> in
- *   <tt>event[replyPumpNamePath[0]][replyPumpNamePath[1]]...</tt> In other
- *   words, examine each array entry in @a replyPumpNamePath in turn. If it's an
- *   <tt>LLSD::String</tt>, the current level of @a event is a map; step down to
- *   that map entry. If it's an <tt>LLSD::Integer</tt>, the current level of @a
- *   event is an array; step down to that array entry. The last array entry in
- *   @a replyPumpNamePath specifies the entry in the lowest-level structure in
- *   @a event into which to store <tt>replyPump.getName()</tt>.
- */
-template <typename SELF>
-LLSD postAndWait(SELF& self, const LLSD& event, const LLEventPumpOrPumpName& requestPump,
-                 const LLEventPumpOrPumpName& replyPump, const LLSD& replyPumpNamePath=LLSD())
-{
-    // declare the future
-    boost::coroutines::future<LLSD> future(self);
-    // make a callback that will assign a value to the future, and listen on
-    // the specified LLEventPump with that callback
-    std::string listenerName(LLEventDetail::listenerNameForCoro(self));
-    LLTempBoundListener connection(
-        replyPump.getPump().listen(listenerName,
-                                   voidlistener(boost::coroutines::make_callback(future))));
-    // skip the "post" part if requestPump is default-constructed
-    if (requestPump)
-    {
-        // If replyPumpNamePath is non-empty, store the replyPump name in the
-        // request event.
-        LLSD modevent(event);
-        LLEventDetail::storeToLLSDPath(modevent, replyPumpNamePath, replyPump.getPump().getName());
-		LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << listenerName
-                                 << " posting to " << requestPump.getPump().getName()
-								 << LL_ENDL;
-
-		// *NOTE:Mani - Removed because modevent could contain user's hashed passwd.
-		//                         << ": " << modevent << LL_ENDL;
-        requestPump.getPump().post(modevent);
-    }
-    LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << listenerName
-                             << " about to wait on LLEventPump " << replyPump.getPump().getName()
-                             << LL_ENDL;
-    // trying to dereference ("resolve") the future makes us wait for it
-    LLSD value(*future);
-    LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << listenerName
-                             << " resuming with " << value << LL_ENDL;
-    // returning should disconnect the connection
-    return value;
-}
-
-/// Wait for the next event on the specified LLEventPump. Pass either the
-/// LLEventPump& or its string name.
-template <typename SELF>
-LLSD waitForEventOn(SELF& self, const LLEventPumpOrPumpName& pump)
-{
-    // This is now a convenience wrapper for postAndWait().
-    return postAndWait(self, LLSD(), LLEventPumpOrPumpName(), pump);
-}
-
-/// return type for two-pump variant of waitForEventOn()
-typedef std::pair<LLSD, int> LLEventWithID;
-
-namespace LLEventDetail
-{
-    /**
-     * This helper is specifically for the two-pump version of waitForEventOn().
-     * We use a single future object, but we want to listen on two pumps with it.
-     * Since we must still adapt from (the callable constructed by)
-     * boost::coroutines::make_callback() (void return) to provide an event
-     * listener (bool return), we've adapted LLVoidListener for the purpose. The
-     * basic idea is that we construct a distinct instance of WaitForEventOnHelper
-     * -- binding different instance data -- for each of the pumps. Then, when a
-     * pump delivers an LLSD value to either WaitForEventOnHelper, it can combine
-     * that LLSD with its discriminator to feed the future object.
-     */
-    template <typename LISTENER>
-    class WaitForEventOnHelper
-    {
-    public:
-        WaitForEventOnHelper(const LISTENER& listener, int discriminator):
-            mListener(listener),
-            mDiscrim(discriminator)
-        {}
-        // this signature is required for an LLEventPump listener
-        bool operator()(const LLSD& event)
-        {
-            // our future object is defined to accept LLEventWithID
-            mListener(LLEventWithID(event, mDiscrim));
-            // don't swallow the event, let other listeners see it
-            return false;
-        }
-    private:
-        LISTENER mListener;
-        const int mDiscrim;
-    };
-
-    /// WaitForEventOnHelper type-inference helper
-    template <typename LISTENER>
-    WaitForEventOnHelper<LISTENER> wfeoh(const LISTENER& listener, int discriminator)
-    {
-        return WaitForEventOnHelper<LISTENER>(listener, discriminator);
-    }
-} // namespace LLEventDetail
-
-/**
- * This function waits for a reply on either of two specified LLEventPumps.
- * Otherwise, it closely resembles postAndWait(); please see the documentation
- * for that function for detailed parameter info.
- *
- * While we could have implemented the single-pump variant in terms of this
- * one, there's enough added complexity here to make it worthwhile to give the
- * single-pump variant its own straightforward implementation. Conversely,
- * though we could use preprocessor logic to generate n-pump overloads up to
- * BOOST_COROUTINE_WAIT_MAX, we don't foresee a use case. This two-pump
- * overload exists because certain event APIs are defined in terms of a reply
- * LLEventPump and an error LLEventPump.
- *
- * The LLEventWithID return value provides not only the received event, but
- * the index of the pump on which it arrived (0 or 1).
- *
- * @note
- * I'd have preferred to overload the name postAndWait() for both signatures.
- * But consider the following ambiguous call:
- * @code
- * postAndWait(self, LLSD(), requestPump, replyPump, "someString");
- * @endcode
- * "someString" could be converted to either LLSD (@a replyPumpNamePath for
- * the single-pump function) or LLEventOrPumpName (@a replyPump1 for two-pump
- * function).
- *
- * It seems less burdensome to write postAndWait2() than to write either
- * LLSD("someString") or LLEventOrPumpName("someString").
- */
-template <typename SELF>
-LLEventWithID postAndWait2(SELF& self, const LLSD& event,
-                           const LLEventPumpOrPumpName& requestPump,
-                           const LLEventPumpOrPumpName& replyPump0,
-                           const LLEventPumpOrPumpName& replyPump1,
-                           const LLSD& replyPump0NamePath=LLSD(),
-                           const LLSD& replyPump1NamePath=LLSD())
-{
-    // declare the future
-    boost::coroutines::future<LLEventWithID> future(self);
-    // either callback will assign a value to this future; listen on
-    // each specified LLEventPump with a callback
-    std::string name(LLEventDetail::listenerNameForCoro(self));
-    LLTempBoundListener connection0(
-        replyPump0.getPump().listen(name + "a",
-                               LLEventDetail::wfeoh(boost::coroutines::make_callback(future), 0)));
-    LLTempBoundListener connection1(
-        replyPump1.getPump().listen(name + "b",
-                               LLEventDetail::wfeoh(boost::coroutines::make_callback(future), 1)));
-    // skip the "post" part if requestPump is default-constructed
-    if (requestPump)
-    {
-        // If either replyPumpNamePath is non-empty, store the corresponding
-        // replyPump name in the request event.
-        LLSD modevent(event);
-        LLEventDetail::storeToLLSDPath(modevent, replyPump0NamePath,
-                                       replyPump0.getPump().getName());
-        LLEventDetail::storeToLLSDPath(modevent, replyPump1NamePath,
-                                       replyPump1.getPump().getName());
-        LL_DEBUGS("lleventcoro") << "postAndWait2(): coroutine " << name
-                                 << " posting to " << requestPump.getPump().getName()
-                                 << ": " << modevent << LL_ENDL;
-        requestPump.getPump().post(modevent);
-    }
-    LL_DEBUGS("lleventcoro") << "postAndWait2(): coroutine " << name
-                             << " about to wait on LLEventPumps " << replyPump0.getPump().getName()
-                             << ", " << replyPump1.getPump().getName() << LL_ENDL;
-    // trying to dereference ("resolve") the future makes us wait for it
-    LLEventWithID value(*future);
-    LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << name
-                             << " resuming with (" << value.first << ", " << value.second << ")"
-                             << LL_ENDL;
-    // returning should disconnect both connections
-    return value;
-}
-
-/**
- * Wait for the next event on either of two specified LLEventPumps.
- */
-template <typename SELF>
-LLEventWithID
-waitForEventOn(SELF& self,
-               const LLEventPumpOrPumpName& pump0, const LLEventPumpOrPumpName& pump1)
-{
-    // This is now a convenience wrapper for postAndWait2().
-    return postAndWait2(self, LLSD(), LLEventPumpOrPumpName(), pump0, pump1);
-}
-
-/**
- * Helper for the two-pump variant of waitForEventOn(), e.g.:
- *
- * @code
- * LLSD reply = errorException(waitForEventOn(self, replyPump, errorPump),
- *                             "error response from login.cgi");
- * @endcode
- *
- * Examines an LLEventWithID, assuming that the second pump (pump 1) is
- * listening for an error indication. If the incoming data arrived on pump 1,
- * throw an LLErrorEvent exception. If the incoming data arrived on pump 0,
- * just return it. Since a normal return can only be from pump 0, we no longer
- * need the LLEventWithID's discriminator int; we can just return the LLSD.
- *
- * @note I'm not worried about introducing the (fairly generic) name
- * errorException() into global namespace, because how many other overloads of
- * the same name are going to accept an LLEventWithID parameter?
- */
-LLSD errorException(const LLEventWithID& result, const std::string& desc);
-
-/**
- * Exception thrown by errorException(). We don't call this LLEventError
- * because it's not an error in event processing: rather, this exception
- * announces an event that bears error information (for some other API).
- */
-class LL_COMMON_API LLErrorEvent: public std::runtime_error
-{
-public:
-    LLErrorEvent(const std::string& what, const LLSD& data):
-        std::runtime_error(what),
-        mData(data)
-    {}
-    virtual ~LLErrorEvent() throw() {}
-
-    LLSD getData() const { return mData; }
-
-private:
-    LLSD mData;
-};
-
-/**
- * Like errorException(), save that this trips a fatal error using LL_ERRS
- * rather than throwing an exception.
- */
-LL_COMMON_API LLSD errorLog(const LLEventWithID& result, const std::string& desc);
-
-/**
- * Certain event APIs require the name of an LLEventPump on which they should
- * post results. While it works to invent a distinct name and let
- * LLEventPumps::obtain() instantiate the LLEventPump as a "named singleton,"
- * in a certain sense it's more robust to instantiate a local LLEventPump and
- * provide its name instead. This class packages the following idiom:
- *
- * 1. Instantiate a local LLCoroEventPump, with an optional name prefix.
- * 2. Provide its actual name to the event API in question as the name of the
- *    reply LLEventPump.
- * 3. Initiate the request to the event API.
- * 4. Call your LLEventTempStream's wait() method to wait for the reply.
- * 5. Let the LLCoroEventPump go out of scope.
- */
-class LL_COMMON_API LLCoroEventPump
-{
-public:
-    LLCoroEventPump(const std::string& name="coro"):
-        mPump(name, true)           // allow tweaking the pump instance name
-    {}
-    /// It's typical to request the LLEventPump name to direct an event API to
-    /// send its response to this pump.
-    std::string getName() const { return mPump.getName(); }
-    /// Less typically, we'd request the pump itself for some reason.
-    LLEventPump& getPump() { return mPump; }
-
-    /**
-     * Wait for an event on this LLEventPump.
-     *
-     * @note
-     * The other major usage pattern we considered was to bind @c self at
-     * LLCoroEventPump construction time, which would avoid passing the
-     * parameter to each wait() call. But if we were going to bind @c self as
-     * a class member, we'd need to specify a class template parameter
-     * indicating its type. The big advantage of passing it to the wait() call
-     * is that the type can be implicit.
-     */
-    template <typename SELF>
-    LLSD wait(SELF& self)
-    {
-        return waitForEventOn(self, mPump);
-    }
-
-    template <typename SELF>
-    LLSD postAndWait(SELF& self, const LLSD& event, const LLEventPumpOrPumpName& requestPump,
-                     const LLSD& replyPumpNamePath=LLSD())
-    {
-        return ::postAndWait(self, event, requestPump, mPump, replyPumpNamePath);
-    }
-
-private:
-    LLEventStream mPump;
-};
-
-/**
- * Other event APIs require the names of two different LLEventPumps: one for
- * success response, the other for error response. Extend LLCoroEventPump
- * for the two-pump use case.
- */
-class LL_COMMON_API LLCoroEventPumps
-{
-public:
-    LLCoroEventPumps(const std::string& name="coro",
-                     const std::string& suff0="Reply",
-                     const std::string& suff1="Error"):
-        mPump0(name + suff0, true),   // allow tweaking the pump instance name
-        mPump1(name + suff1, true)
-    {}
-    /// request pump 0's name
-    std::string getName0() const { return mPump0.getName(); }
-    /// request pump 1's name
-    std::string getName1() const { return mPump1.getName(); }
-    /// request both names
-    std::pair<std::string, std::string> getNames() const
-    {
-        return std::pair<std::string, std::string>(mPump0.getName(), mPump1.getName());
-    }
-
-    /// request pump 0
-    LLEventPump& getPump0() { return mPump0; }
-    /// request pump 1
-    LLEventPump& getPump1() { return mPump1; }
-
-    /// waitForEventOn(self, either of our two LLEventPumps)
-    template <typename SELF>
-    LLEventWithID wait(SELF& self)
-    {
-        return waitForEventOn(self, mPump0, mPump1);
-    }
-
-    /// errorException(wait(self))
-    template <typename SELF>
-    LLSD waitWithException(SELF& self)
-    {
-        return errorException(wait(self), std::string("Error event on ") + getName1());
-    }
-
-    /// errorLog(wait(self))
-    template <typename SELF>
-    LLSD waitWithLog(SELF& self)
-    {
-        return errorLog(wait(self), std::string("Error event on ") + getName1());
-    }
-
-    template <typename SELF>
-    LLEventWithID postAndWait(SELF& self, const LLSD& event,
-                              const LLEventPumpOrPumpName& requestPump,
-                              const LLSD& replyPump0NamePath=LLSD(),
-                              const LLSD& replyPump1NamePath=LLSD())
-    {
-        return postAndWait2(self, event, requestPump, mPump0, mPump1,
-                            replyPump0NamePath, replyPump1NamePath);
-    }
-
-    template <typename SELF>
-    LLSD postAndWaitWithException(SELF& self, const LLSD& event,
-                                  const LLEventPumpOrPumpName& requestPump,
-                                  const LLSD& replyPump0NamePath=LLSD(),
-                                  const LLSD& replyPump1NamePath=LLSD())
-    {
-        return errorException(postAndWait(self, event, requestPump,
-                                          replyPump0NamePath, replyPump1NamePath),
-                              std::string("Error event on ") + getName1());
-    }
-
-    template <typename SELF>
-    LLSD postAndWaitWithLog(SELF& self, const LLSD& event,
-                            const LLEventPumpOrPumpName& requestPump,
-                            const LLSD& replyPump0NamePath=LLSD(),
-                            const LLSD& replyPump1NamePath=LLSD())
-    {
-        return errorLog(postAndWait(self, event, requestPump,
-                                    replyPump0NamePath, replyPump1NamePath),
-                        std::string("Error event on ") + getName1());
-    }
-
-private:
-    LLEventStream mPump0, mPump1;
-};
-
-#endif /* ! defined(LL_LLEVENTCORO_H) */

indra/llcommon/lleventdispatcher.cpp

@@ -1,672 +0,0 @@
-/**
- * @file   lleventdispatcher.cpp
- * @author Nat Goodspeed
- * @date   2009-06-18
- * @brief  Implementation for lleventdispatcher.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if LL_WINDOWS
-#pragma warning (disable : 4355) // 'this' used in initializer list: yes, intentionally
-#endif
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-#include "lleventdispatcher.h"
-// STL headers
-// std headers
-// external library headers
-// other Linden headers
-#include "llevents.h"
-#include "llerror.h"
-#include "llsdutil.h"
-#include "stringize.h"
-#include <memory>                   // std::auto_ptr
-
-/*****************************************************************************
-*   LLSDArgsSource
-*****************************************************************************/
-/**
- * Store an LLSD array, producing its elements one at a time. Die with LL_ERRS
- * if the consumer requests more elements than the array contains.
- */
-class LL_COMMON_API LLSDArgsSource
-{
-public:
-    LLSDArgsSource(const std::string function, const LLSD& args);
-    ~LLSDArgsSource();
-
-    LLSD next();
-
-    void done() const;
-
-private:
-    std::string _function;
-    LLSD _args;
-    LLSD::Integer _index;
-};
-
-LLSDArgsSource::LLSDArgsSource(const std::string function, const LLSD& args):
-    _function(function),
-    _args(args),
-    _index(0)
-{
-    if (! (_args.isUndefined() || _args.isArray()))
-    {
-        LL_ERRS("LLSDArgsSource") << _function << " needs an args array instead of "
-                                  << _args << LL_ENDL;
-    }
-}
-
-LLSDArgsSource::~LLSDArgsSource()
-{
-    done();
-}
-
-LLSD LLSDArgsSource::next()
-{
-    if (_index >= _args.size())
-    {
-        LL_ERRS("LLSDArgsSource") << _function << " requires more arguments than the "
-                                  << _args.size() << " provided: " << _args << LL_ENDL;
-    }
-    return _args[_index++];
-}
-
-void LLSDArgsSource::done() const
-{
-    if (_index < _args.size())
-    {
-        LL_WARNS("LLSDArgsSource") << _function << " only consumed " << _index
-                                   << " of the " << _args.size() << " arguments provided: "
-                                   << _args << LL_ENDL;
-    }
-}
-
-/*****************************************************************************
-*   LLSDArgsMapper
-*****************************************************************************/
-/**
- * From a formal parameters description and a map of arguments, construct an
- * arguments array.
- *
- * That is, given:
- * - an LLSD array of length n containing parameter-name strings,
- *   corresponding to the arguments of a function of interest
- * - an LLSD collection specifying default parameter values, either:
- *   - an LLSD array of length m <= n, matching the rightmost m params, or
- *   - an LLSD map explicitly stating default name=value pairs
- * - an LLSD map of parameter names and actual values for a particular
- *   function call
- * construct an LLSD array of actual argument values for this function call.
- *
- * The parameter-names array and the defaults collection describe the function
- * being called. The map might vary with every call, providing argument values
- * for the described parameters.
- *
- * The array of parameter names must match the number of parameters expected
- * by the function of interest.
- *
- * If you pass a map of default parameter values, it provides default values
- * as you might expect. It is an error to specify a default value for a name
- * not listed in the parameters array.
- *
- * If you pass an array of default parameter values, it is mapped to the
- * rightmost m of the n parameter names. It is an error if the default-values
- * array is longer than the parameter-names array. Consider the following
- * parameter names: ["a", "b", "c", "d"].
- *
- * - An empty array of default values (or an isUndefined() value) asserts that
- *   every one of the above parameter names is required.
- * - An array of four default values [1, 2, 3, 4] asserts that every one of
- *   the above parameters is optional. If the current parameter map is empty,
- *   they will be passed to the function as [1, 2, 3, 4].
- * - An array of two default values [11, 12] asserts that parameters "a" and
- *   "b" are required, while "c" and "d" are optional, having default values
- *   "c"=11 and "d"=12.
- *
- * The arguments array is constructed as follows:
- *
- * - Arguments-map keys not found in the parameter-names array are ignored.
- * - Entries from the map provide values for an improper subset of the
- *   parameters named in the parameter-names array. This results in a
- *   tentative values array with "holes." (size of map) + (number of holes) =
- *   (size of names array)
- * - Holes are filled with the default values.
- * - Any remaining holes constitute an error.
- */
-class LL_COMMON_API LLSDArgsMapper
-{
-public:
-    /// Accept description of function: function name, param names, param
-    /// default values
-    LLSDArgsMapper(const std::string& function, const LLSD& names, const LLSD& defaults);
-
-    /// Given arguments map, return LLSD::Array of parameter values, or LL_ERRS.
-    LLSD map(const LLSD& argsmap) const;
-
-private:
-    static std::string formatlist(const LLSD&);
-
-    // The function-name string is purely descriptive. We want error messages
-    // to be able to indicate which function's LLSDArgsMapper has the problem.
-    std::string _function;
-    // Store the names array pretty much as given.
-    LLSD _names;
-    // Though we're handed an array of name strings, it's more useful to us to
-    // store it as a map from name string to position index. Of course that's
-    // easy to generate from the incoming names array, but why do it more than
-    // once?
-    typedef std::map<LLSD::String, LLSD::Integer> IndexMap;
-    IndexMap _indexes;
-    // Generated array of default values, aligned with the array of param names.
-    LLSD _defaults;
-    // Indicate whether we have a default value for each param.
-    typedef std::vector<char> FilledVector;
-    FilledVector _has_dft;
-};
-
-LLSDArgsMapper::LLSDArgsMapper(const std::string& function,
-                               const LLSD& names, const LLSD& defaults):
-    _function(function),
-    _names(names),
-    _has_dft(names.size())
-{
-    if (! (_names.isUndefined() || _names.isArray()))
-    {
-        LL_ERRS("LLSDArgsMapper") << function << " names must be an array, not " << names << LL_ENDL;
-    }
-    LLSD::Integer nparams(_names.size());
-    // From _names generate _indexes.
-    for (LLSD::Integer ni = 0, nend = _names.size(); ni < nend; ++ni)
-    {
-        _indexes[_names[ni]] = ni;
-    }
-
-    // Presize _defaults() array so we don't have to resize it more than once.
-    // All entries are initialized to LLSD(); but since _has_dft is still all
-    // 0, they're all "holes" for now.
-    if (nparams)
-    {
-        _defaults[nparams - 1] = LLSD();
-    }
-
-    if (defaults.isUndefined() || defaults.isArray())
-    {
-        LLSD::Integer ndefaults = defaults.size();
-        // defaults is a (possibly empty) array. Right-align it with names.
-        if (ndefaults > nparams)
-        {
-            LL_ERRS("LLSDArgsMapper") << function << " names array " << names
-                                      << " shorter than defaults array " << defaults << LL_ENDL;
-        }
-
-        // Offset by which we slide defaults array right to right-align with
-        // _names array
-        LLSD::Integer offset = nparams - ndefaults;
-        // Fill rightmost _defaults entries from defaults, and mark them as
-        // filled
-        for (LLSD::Integer i = 0, iend = ndefaults; i < iend; ++i)
-        {
-            _defaults[i + offset] = defaults[i];
-            _has_dft[i + offset] = 1;
-        }
-    }
-    else if (defaults.isMap())
-    {
-        // defaults is a map. Use it to populate the _defaults array.
-        LLSD bogus;
-        for (LLSD::map_const_iterator mi(defaults.beginMap()), mend(defaults.endMap());
-             mi != mend; ++mi)
-        {
-            IndexMap::const_iterator ixit(_indexes.find(mi->first));
-            if (ixit == _indexes.end())
-            {
-                bogus.append(mi->first);
-                continue;
-            }
-
-            LLSD::Integer pos = ixit->second;
-            // Store default value at that position in the _defaults array.
-            _defaults[pos] = mi->second;
-            // Don't forget to record the fact that we've filled this
-            // position.
-            _has_dft[pos] = 1;
-        }
-        if (bogus.size())
-        {
-            LL_ERRS("LLSDArgsMapper") << function << " defaults specified for nonexistent params "
-                                      << formatlist(bogus) << LL_ENDL;
-        }
-    }
-    else
-    {
-        LL_ERRS("LLSDArgsMapper") << function << " defaults must be a map or an array, not "
-                                  << defaults << LL_ENDL;
-    }
-}
-
-LLSD LLSDArgsMapper::map(const LLSD& argsmap) const
-{
-    if (! (argsmap.isUndefined() || argsmap.isMap() || argsmap.isArray()))
-    {
-        LL_ERRS("LLSDArgsMapper") << _function << " map() needs a map or array, not "
-                                  << argsmap << LL_ENDL;
-    }
-    // Initialize the args array. Indexing a non-const LLSD array grows it
-    // to appropriate size, but we don't want to resize this one on each
-    // new operation. Just make it as big as we need before we start
-    // stuffing values into it.
-    LLSD args(LLSD::emptyArray());
-    if (_defaults.size() == 0)
-    {
-        // If this function requires no arguments, fast exit. (Don't try to
-        // assign to args[-1].)
-        return args;
-    }
-    args[_defaults.size() - 1] = LLSD();
-
-    // Get a vector of chars to indicate holes. It's tempting to just scan
-    // for LLSD::isUndefined() values after filling the args array from
-    // the map, but it's plausible for caller to explicitly pass
-    // isUndefined() as the value of some parameter name. That's legal
-    // since isUndefined() has well-defined conversions (default value)
-    // for LLSD data types. So use a whole separate array for detecting
-    // holes. (Avoid std::vector<bool> which is known to be odd -- can we
-    // iterate?)
-    FilledVector filled(args.size());
-
-    if (argsmap.isArray())
-    {
-        // Fill args from array. If there are too many args in passed array,
-        // ignore the rest.
-        LLSD::Integer size(argsmap.size());
-        if (size > args.size())
-        {
-            // We don't just use std::min() because we want to sneak in this
-            // warning if caller passes too many args.
-            LL_WARNS("LLSDArgsMapper") << _function << " needs " << args.size()
-                                       << " params, ignoring last " << (size - args.size())
-                                       << " of passed " << size << ": " << argsmap << LL_ENDL;
-            size = args.size();
-        }
-        for (LLSD::Integer i(0); i < size; ++i)
-        {
-            // Copy the actual argument from argsmap
-            args[i] = argsmap[i];
-            // Note that it's been filled
-            filled[i] = 1;
-        }
-    }
-    else
-    {
-        // argsmap is in fact a map. Walk the map.
-        for (LLSD::map_const_iterator mi(argsmap.beginMap()), mend(argsmap.endMap());
-             mi != mend; ++mi)
-        {
-            // mi->first is a parameter-name string, with mi->second its
-            // value. Look up the name's position index in _indexes.
-            IndexMap::const_iterator ixit(_indexes.find(mi->first));
-            if (ixit == _indexes.end())
-            {
-                // Allow for a map containing more params than were passed in
-                // our names array. Caller typically receives a map containing
-                // the function name, cruft such as reqid, etc. Ignore keys
-                // not defined in _indexes.
-                LL_DEBUGS("LLSDArgsMapper") << _function << " ignoring "
-                                            << mi->first << "=" << mi->second << LL_ENDL;
-                continue;
-            }
-            LLSD::Integer pos = ixit->second;
-            // Store the value at that position in the args array.
-            args[pos] = mi->second;
-            // Don't forget to record the fact that we've filled this
-            // position.
-            filled[pos] = 1;
-        }
-    }
-
-    // Fill any remaining holes from _defaults.
-    LLSD unfilled(LLSD::emptyArray());
-    for (LLSD::Integer i = 0, iend = args.size(); i < iend; ++i)
-    {
-        if (! filled[i])
-        {
-            // If there's no default value for this parameter, that's an
-            // error.
-            if (! _has_dft[i])
-            {
-                unfilled.append(_names[i]);
-            }
-            else
-            {
-                args[i] = _defaults[i];
-            }
-        }
-    }
-    // If any required args -- args without defaults -- were left unfilled
-    // by argsmap, that's a problem.
-    if (unfilled.size())
-    {
-        LL_ERRS("LLSDArgsMapper") << _function << " missing required arguments "
-                                  << formatlist(unfilled) << " from " << argsmap << LL_ENDL;
-    }
-
-    // done
-    return args;
-}
-
-std::string LLSDArgsMapper::formatlist(const LLSD& list)
-{
-    std::ostringstream out;
-    const char* delim = "";
-    for (LLSD::array_const_iterator li(list.beginArray()), lend(list.endArray());
-         li != lend; ++li)
-    {
-        out << delim << li->asString();
-        delim = ", ";
-    }
-    return out.str();
-}
-
-LLEventDispatcher::LLEventDispatcher(const std::string& desc, const std::string& key):
-    mDesc(desc),
-    mKey(key)
-{
-}
-
-LLEventDispatcher::~LLEventDispatcher()
-{
-}
-
-/**
- * DispatchEntry subclass used for callables accepting(const LLSD&)
- */
-struct LLEventDispatcher::LLSDDispatchEntry: public LLEventDispatcher::DispatchEntry
-{
-    LLSDDispatchEntry(const std::string& desc, const Callable& func, const LLSD& required):
-        DispatchEntry(desc),
-        mFunc(func),
-        mRequired(required)
-    {}
-
-    Callable mFunc;
-    LLSD mRequired;
-
-    virtual void call(const std::string& desc, const LLSD& event) const
-    {
-        // Validate the syntax of the event itself.
-        std::string mismatch(llsd_matches(mRequired, event));
-        if (! mismatch.empty())
-        {
-            LL_ERRS("LLEventDispatcher") << desc << ": bad request: " << mismatch << LL_ENDL;
-        }
-        // Event syntax looks good, go for it!
-        mFunc(event);
-    }
-
-    virtual LLSD addMetadata(LLSD meta) const
-    {
-        meta["required"] = mRequired;
-        return meta;
-    }
-};
-
-/**
- * DispatchEntry subclass for passing LLSD to functions accepting
- * arbitrary argument types (convertible via LLSDParam)
- */
-struct LLEventDispatcher::ParamsDispatchEntry: public LLEventDispatcher::DispatchEntry
-{
-    ParamsDispatchEntry(const std::string& desc, const invoker_function& func):
-        DispatchEntry(desc),
-        mInvoker(func)
-    {}
-
-    invoker_function mInvoker;
-
-    virtual void call(const std::string& desc, const LLSD& event) const
-    {
-        LLSDArgsSource src(desc, event);
-        mInvoker(boost::bind(&LLSDArgsSource::next, boost::ref(src)));
-    }
-};
-
-/**
- * DispatchEntry subclass for dispatching LLSD::Array to functions accepting
- * arbitrary argument types (convertible via LLSDParam)
- */
-struct LLEventDispatcher::ArrayParamsDispatchEntry: public LLEventDispatcher::ParamsDispatchEntry
-{
-    ArrayParamsDispatchEntry(const std::string& desc, const invoker_function& func,
-                             LLSD::Integer arity):
-        ParamsDispatchEntry(desc, func),
-        mArity(arity)
-    {}
-
-    LLSD::Integer mArity;
-
-    virtual LLSD addMetadata(LLSD meta) const
-    {
-        LLSD array(LLSD::emptyArray());
-        // Resize to number of arguments required
-        if (mArity)
-            array[mArity - 1] = LLSD();
-        llassert_always(array.size() == mArity);
-        meta["required"] = array;
-        return meta;
-    }
-};
-
-/**
- * DispatchEntry subclass for dispatching LLSD::Map to functions accepting
- * arbitrary argument types (convertible via LLSDParam)
- */
-struct LLEventDispatcher::MapParamsDispatchEntry: public LLEventDispatcher::ParamsDispatchEntry
-{
-    MapParamsDispatchEntry(const std::string& name, const std::string& desc,
-                           const invoker_function& func,
-                           const LLSD& params, const LLSD& defaults):
-        ParamsDispatchEntry(desc, func),
-        mMapper(name, params, defaults),
-        mRequired(LLSD::emptyMap())
-    {
-        // Build the set of all param keys, then delete the ones that are
-        // optional. What's left are the ones that are required.
-        for (LLSD::array_const_iterator pi(params.beginArray()), pend(params.endArray());
-             pi != pend; ++pi)
-        {
-            mRequired[pi->asString()] = LLSD();
-        }
-
-        if (defaults.isArray() || defaults.isUndefined())
-        {
-            // Right-align the params and defaults arrays.
-            LLSD::Integer offset = params.size() - defaults.size();
-            // Now the name of every defaults[i] is at params[i + offset].
-            for (LLSD::Integer i(0), iend(defaults.size()); i < iend; ++i)
-            {
-                // Erase this optional param from mRequired.
-                mRequired.erase(params[i + offset].asString());
-                // Instead, make an entry in mOptional with the default
-                // param's name and value.
-                mOptional[params[i + offset].asString()] = defaults[i];
-            }
-        }
-        else if (defaults.isMap())
-        {
-            // if defaults is already a map, then it's already in the form we
-            // intend to deliver in metadata
-            mOptional = defaults;
-            // Just delete from mRequired every key appearing in mOptional.
-            for (LLSD::map_const_iterator mi(mOptional.beginMap()), mend(mOptional.endMap());
-                 mi != mend; ++mi)
-            {
-                mRequired.erase(mi->first);
-            }
-        }
-    }
-
-    LLSDArgsMapper mMapper;
-    LLSD mRequired;
-    LLSD mOptional;
-
-    virtual void call(const std::string& desc, const LLSD& event) const
-    {
-        // Just convert from LLSD::Map to LLSD::Array using mMapper, then pass
-        // to base-class call() method.
-        ParamsDispatchEntry::call(desc, mMapper.map(event));
-    }
-
-    virtual LLSD addMetadata(LLSD meta) const
-    {
-        meta["required"] = mRequired;
-        meta["optional"] = mOptional;
-        return meta;
-    }
-};
-
-void LLEventDispatcher::addArrayParamsDispatchEntry(const std::string& name,
-                                                    const std::string& desc,
-                                                    const invoker_function& invoker,
-                                                    LLSD::Integer arity)
-{
-    mDispatch.insert(
-        DispatchMap::value_type(name, DispatchMap::mapped_type(
-                                    new ArrayParamsDispatchEntry(desc, invoker, arity))));
-}
-
-void LLEventDispatcher::addMapParamsDispatchEntry(const std::string& name,
-                                                  const std::string& desc,
-                                                  const invoker_function& invoker,
-                                                  const LLSD& params,
-                                                  const LLSD& defaults)
-{
-    mDispatch.insert(
-        DispatchMap::value_type(name, DispatchMap::mapped_type(
-                                    new MapParamsDispatchEntry(name, desc, invoker, params, defaults))));
-}
-
-/// Register a callable by name
-void LLEventDispatcher::add(const std::string& name, const std::string& desc,
-                            const Callable& callable, const LLSD& required)
-{
-    mDispatch.insert(
-        DispatchMap::value_type(name, DispatchMap::mapped_type(
-                                    new LLSDDispatchEntry(desc, callable, required))));
-}
-
-void LLEventDispatcher::addFail(const std::string& name, const std::string& classname) const
-{
-    LL_ERRS("LLEventDispatcher") << "LLEventDispatcher(" << mDesc << ")::add(" << name
-                                 << "): " << classname << " is not a subclass "
-                                 << "of LLEventDispatcher" << LL_ENDL;
-}
-
-/// Unregister a callable
-bool LLEventDispatcher::remove(const std::string& name)
-{
-    DispatchMap::iterator found = mDispatch.find(name);
-    if (found == mDispatch.end())
-    {
-        return false;
-    }
-    mDispatch.erase(found);
-    return true;
-}
-
-/// Call a registered callable with an explicitly-specified name. If no
-/// such callable exists, die with LL_ERRS.
-void LLEventDispatcher::operator()(const std::string& name, const LLSD& event) const
-{
-    if (! try_call(name, event))
-    {
-        LL_ERRS("LLEventDispatcher") << "LLEventDispatcher(" << mDesc << "): '" << name
-                                     << "' not found" << LL_ENDL;
-    }
-}
-
-/// Extract the @a key value from the incoming @a event, and call the
-/// callable whose name is specified by that map @a key. If no such
-/// callable exists, die with LL_ERRS.
-void LLEventDispatcher::operator()(const LLSD& event) const
-{
-    // This could/should be implemented in terms of the two-arg overload.
-    // However -- we can produce a more informative error message.
-    std::string name(event[mKey]);
-    if (! try_call(name, event))
-    {
-        LL_ERRS("LLEventDispatcher") << "LLEventDispatcher(" << mDesc << "): bad " << mKey
-                                     << " value '" << name << "'" << LL_ENDL;
-    }
-}
-
-bool LLEventDispatcher::try_call(const LLSD& event) const
-{
-    return try_call(event[mKey], event);
-}
-
-bool LLEventDispatcher::try_call(const std::string& name, const LLSD& event) const
-{
-    DispatchMap::const_iterator found = mDispatch.find(name);
-    if (found == mDispatch.end())
-    {
-        return false;
-    }
-    // Found the name, so it's plausible to even attempt the call.
-    found->second->call(STRINGIZE("LLEventDispatcher(" << mDesc << ") calling '" << name << "'"),
-                        event);
-    return true;                    // tell caller we were able to call
-}
-
-LLSD LLEventDispatcher::getMetadata(const std::string& name) const
-{
-    DispatchMap::const_iterator found = mDispatch.find(name);
-    if (found == mDispatch.end())
-    {
-        return LLSD();
-    }
-    LLSD meta;
-    meta["name"] = name;
-    meta["desc"] = found->second->mDesc;
-    return found->second->addMetadata(meta);
-}
-
-LLDispatchListener::LLDispatchListener(const std::string& pumpname, const std::string& key):
-    LLEventDispatcher(pumpname, key),
-    mPump(pumpname, true),          // allow tweaking for uniqueness
-    mBoundListener(mPump.listen("self", boost::bind(&LLDispatchListener::process, this, _1)))
-{
-}
-
-bool LLDispatchListener::process(const LLSD& event)
-{
-    (*this)(event);
-    return false;
-}
-
-LLEventDispatcher::DispatchEntry::DispatchEntry(const std::string& desc):
-    mDesc(desc)
-{}
-

indra/llcommon/lleventdispatcher.h

@@ -1,541 +0,0 @@
-/**
- * @file   lleventdispatcher.h
- * @author Nat Goodspeed
- * @date   2009-06-18
- * @brief  Central mechanism for dispatching events by string name. This is
- *         useful when you have a single LLEventPump listener on which you can
- *         request different operations, vs. instantiating a different
- *         LLEventPump for each such operation.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- *
- * The invoker machinery that constructs a boost::fusion argument list for use
- * with boost::fusion::invoke() is derived from
- * http://www.boost.org/doc/libs/1_45_0/libs/function_types/example/interpreter.hpp
- * whose license information is copied below:
- *
- * "(C) Copyright Tobias Schwinger
- *
- * Use modification and distribution are subject to the boost Software License,
- * Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)."
- */
-
-#if ! defined(LL_LLEVENTDISPATCHER_H)
-#define LL_LLEVENTDISPATCHER_H
-
-// nil is too generic a term to be allowed to be a global macro. In
-// particular, boost::fusion defines a 'class nil' (properly encapsulated in a
-// namespace) that a global 'nil' macro breaks badly.
-#if defined(nil)
-// Capture the value of the macro 'nil', hoping int is an appropriate type.
-static const int nil_(nil);
-// Now forget the macro.
-#undef nil
-// Finally, reintroduce 'nil' as a properly-scoped alias for the previously-
-// defined const 'nil_'. Make it static since otherwise it produces duplicate-
-// symbol link errors later.
-static const int& nil(nil_);
-#endif
-
-#include <string>
-#include <boost/shared_ptr.hpp>
-#include <boost/function.hpp>
-#include <boost/bind.hpp>
-#include <boost/iterator/transform_iterator.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/function_types/is_nonmember_callable_builtin.hpp>
-#include <boost/function_types/parameter_types.hpp>
-#include <boost/function_types/function_arity.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/fusion/include/push_back.hpp>
-#include <boost/fusion/include/cons.hpp>
-#include <boost/fusion/include/invoke.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
-#include <typeinfo>
-#include "llevents.h"
-#include "llsdutil.h"
-
-class LLSD;
-
-/**
- * Given an LLSD map, examine a string-valued key and call a corresponding
- * callable. This class is designed to be contained by an LLEventPump
- * listener class that will register some of its own methods, though any
- * callable can be used.
- */
-class LL_COMMON_API LLEventDispatcher
-{
-public:
-    LLEventDispatcher(const std::string& desc, const std::string& key);
-    virtual ~LLEventDispatcher();
-
-    /// @name Register functions accepting(const LLSD&)
-    //@{
-
-    /// Accept any C++ callable with the right signature, typically a
-    /// boost::bind() expression
-    typedef boost::function<void(const LLSD&)> Callable;
-
-    /**
-     * Register a @a callable by @a name. The passed @a callable accepts a
-     * single LLSD value and uses it in any way desired, e.g. extract
-     * parameters and call some other function. The optional @a required
-     * parameter is used to validate the structure of each incoming event (see
-     * llsd_matches()).
-     */
-    void add(const std::string& name,
-             const std::string& desc,
-             const Callable& callable,
-             const LLSD& required=LLSD());
-
-    /**
-     * The case of a free function (or static method) accepting(const LLSD&)
-     * could also be intercepted by the arbitrary-args overload below. Ensure
-     * that it's directed to the Callable overload above instead.
-     */
-    void add(const std::string& name,
-             const std::string& desc,
-             void (*f)(const LLSD&),
-             const LLSD& required=LLSD())
-    {
-        add(name, desc, Callable(f), required);
-    }
-
-    /**
-     * Special case: a subclass of this class can pass an unbound member
-     * function pointer (of an LLEventDispatcher subclass) without explicitly
-     * specifying the <tt>boost::bind()</tt> expression. The passed @a method
-     * accepts a single LLSD value, presumably containing other parameters.
-     */
-    template <class CLASS>
-    void add(const std::string& name,
-             const std::string& desc,
-             void (CLASS::*method)(const LLSD&),
-             const LLSD& required=LLSD())
-    {
-        addMethod<CLASS>(name, desc, method, required);
-    }
-
-    /// Overload for both const and non-const methods. The passed @a method
-    /// accepts a single LLSD value, presumably containing other parameters.
-    template <class CLASS>
-    void add(const std::string& name,
-             const std::string& desc,
-             void (CLASS::*method)(const LLSD&) const,
-             const LLSD& required=LLSD())
-    {
-        addMethod<CLASS>(name, desc, method, required);
-    }
-
-    //@}
-
-    /// @name Register functions with arbitrary param lists
-    //@{
-
-    /**
-     * Register a free function with arbitrary parameters. (This also works
-     * for static class methods.)
-     *
-     * @note This supports functions with up to about 6 parameters -- after
-     * that you start getting dismaying compile errors in which
-     * boost::fusion::joint_view is mentioned a surprising number of times.
-     *
-     * When calling this name, pass an LLSD::Array. Each entry in turn will be
-     * converted to the corresponding parameter type using LLSDParam.
-     */
-    template<typename Function>
-    typename boost::enable_if< boost::function_types::is_nonmember_callable_builtin<Function>
-                               >::type add(const std::string& name,
-                                           const std::string& desc,
-                                           Function f);
-
-    /**
-     * Register a nonstatic class method with arbitrary parameters.
-     *
-     * @note This supports functions with up to about 6 parameters -- after
-     * that you start getting dismaying compile errors in which
-     * boost::fusion::joint_view is mentioned a surprising number of times.
-     *
-     * To cover cases such as a method on an LLSingleton we don't yet want to
-     * instantiate, instead of directly storing an instance pointer, accept a
-     * nullary callable returning a pointer/reference to the desired class
-     * instance. If you already have an instance in hand,
-     * boost::lambda::var(instance) or boost::lambda::constant(instance_ptr)
-     * produce suitable callables.
-     *
-     * When calling this name, pass an LLSD::Array. Each entry in turn will be
-     * converted to the corresponding parameter type using LLSDParam.
-     */
-    template<typename Method, typename InstanceGetter>
-    typename boost::enable_if< boost::function_types::is_member_function_pointer<Method>
-                               >::type add(const std::string& name,
-                                           const std::string& desc,
-                                           Method f,
-                                           const InstanceGetter& getter);
-
-    /**
-     * Register a free function with arbitrary parameters. (This also works
-     * for static class methods.)
-     *
-     * @note This supports functions with up to about 6 parameters -- after
-     * that you start getting dismaying compile errors in which
-     * boost::fusion::joint_view is mentioned a surprising number of times.
-     *
-     * Pass an LLSD::Array of parameter names, and optionally another
-     * LLSD::Array of default parameter values, a la LLSDArgsMapper.
-     *
-     * When calling this name, pass an LLSD::Map. We will internally generate
-     * an LLSD::Array using LLSDArgsMapper and then convert each entry in turn
-     * to the corresponding parameter type using LLSDParam.
-     */
-    template<typename Function>
-    typename boost::enable_if< boost::function_types::is_nonmember_callable_builtin<Function>
-                               >::type add(const std::string& name,
-                                           const std::string& desc,
-                                           Function f,
-                                           const LLSD& params,
-                                           const LLSD& defaults=LLSD());
-
-    /**
-     * Register a nonstatic class method with arbitrary parameters.
-     *
-     * @note This supports functions with up to about 6 parameters -- after
-     * that you start getting dismaying compile errors in which
-     * boost::fusion::joint_view is mentioned a surprising number of times.
-     *
-     * To cover cases such as a method on an LLSingleton we don't yet want to
-     * instantiate, instead of directly storing an instance pointer, accept a
-     * nullary callable returning a pointer/reference to the desired class
-     * instance. If you already have an instance in hand,
-     * boost::lambda::var(instance) or boost::lambda::constant(instance_ptr)
-     * produce suitable callables.
-     *
-     * Pass an LLSD::Array of parameter names, and optionally another
-     * LLSD::Array of default parameter values, a la LLSDArgsMapper.
-     *
-     * When calling this name, pass an LLSD::Map. We will internally generate
-     * an LLSD::Array using LLSDArgsMapper and then convert each entry in turn
-     * to the corresponding parameter type using LLSDParam.
-     */
-    template<typename Method, typename InstanceGetter>
-    typename boost::enable_if< boost::function_types::is_member_function_pointer<Method>
-                               >::type add(const std::string& name,
-                                           const std::string& desc,
-                                           Method f,
-                                           const InstanceGetter& getter,
-                                           const LLSD& params,
-                                           const LLSD& defaults=LLSD());
-
-    //@}    
-
-    /// Unregister a callable
-    bool remove(const std::string& name);
-
-    /// Call a registered callable with an explicitly-specified name. If no
-    /// such callable exists, die with LL_ERRS. If the @a event fails to match
-    /// the @a required prototype specified at add() time, die with LL_ERRS.
-    void operator()(const std::string& name, const LLSD& event) const;
-
-    /// Call a registered callable with an explicitly-specified name and
-    /// return <tt>true</tt>. If no such callable exists, return
-    /// <tt>false</tt>. If the @a event fails to match the @a required
-    /// prototype specified at add() time, die with LL_ERRS.
-    bool try_call(const std::string& name, const LLSD& event) const;
-
-    /// Extract the @a key value from the incoming @a event, and call the
-    /// callable whose name is specified by that map @a key. If no such
-    /// callable exists, die with LL_ERRS. If the @a event fails to match the
-    /// @a required prototype specified at add() time, die with LL_ERRS.
-    void operator()(const LLSD& event) const;
-
-    /// Extract the @a key value from the incoming @a event, call the callable
-    /// whose name is specified by that map @a key and return <tt>true</tt>.
-    /// If no such callable exists, return <tt>false</tt>. If the @a event
-    /// fails to match the @a required prototype specified at add() time, die
-    /// with LL_ERRS.
-    bool try_call(const LLSD& event) const;
-
-    /// @name Iterate over defined names
-    //@{
-    typedef std::pair<std::string, std::string> NameDesc;
-
-private:
-    struct DispatchEntry
-    {
-        DispatchEntry(const std::string& desc);
-        virtual ~DispatchEntry() {} // suppress MSVC warning, sigh
-
-        std::string mDesc;
-
-        virtual void call(const std::string& desc, const LLSD& event) const = 0;
-        virtual LLSD addMetadata(LLSD) const = 0;
-    };
-    // Tried using boost::ptr_map<std::string, DispatchEntry>, but ptr_map<>
-    // wants its value type to be "clonable," even just to dereference an
-    // iterator. I don't want to clone entries -- if I have to copy an entry
-    // around, I want it to continue pointing to the same DispatchEntry
-    // subclass object. However, I definitely want DispatchMap to destroy
-    // DispatchEntry if no references are outstanding at the time an entry is
-    // removed. This looks like a job for boost::shared_ptr.
-    typedef std::map<std::string, boost::shared_ptr<DispatchEntry> > DispatchMap;
-
-public:
-    /// We want the flexibility to redefine what data we store per name,
-    /// therefore our public interface doesn't expose DispatchMap iterators,
-    /// or DispatchMap itself, or DispatchEntry. Instead we explicitly
-    /// transform each DispatchMap item to NameDesc on dereferencing.
-    typedef boost::transform_iterator<NameDesc(*)(const DispatchMap::value_type&), DispatchMap::const_iterator> const_iterator;
-    const_iterator begin() const
-    {
-        return boost::make_transform_iterator(mDispatch.begin(), makeNameDesc);
-    }
-    const_iterator end() const
-    {
-        return boost::make_transform_iterator(mDispatch.end(), makeNameDesc);
-    }
-    //@}
-
-    /// Get information about a specific Callable
-    LLSD getMetadata(const std::string& name) const;
-
-    /// Retrieve the LLSD key we use for one-arg <tt>operator()</tt> method
-    std::string getDispatchKey() const { return mKey; }
-
-private:
-    template <class CLASS, typename METHOD>
-    void addMethod(const std::string& name, const std::string& desc,
-                   const METHOD& method, const LLSD& required)
-    {
-        CLASS* downcast = dynamic_cast<CLASS*>(this);
-        if (! downcast)
-        {
-            addFail(name, typeid(CLASS).name());
-        }
-        else
-        {
-            add(name, desc, boost::bind(method, downcast, _1), required);
-        }
-    }
-    void addFail(const std::string& name, const std::string& classname) const;
-
-    std::string mDesc, mKey;
-    DispatchMap mDispatch;
-
-    static NameDesc makeNameDesc(const DispatchMap::value_type& item)
-    {
-        return NameDesc(item.first, item.second->mDesc);
-    }
-
-    struct LLSDDispatchEntry;
-    struct ParamsDispatchEntry;
-    struct ArrayParamsDispatchEntry;
-    struct MapParamsDispatchEntry;
-
-    // Step 2 of parameter analysis. Instantiating invoker<some_function_type>
-    // implicitly sets its From and To parameters to the (compile time) begin
-    // and end iterators over that function's parameter types.
-    template< typename Function
-              , class From = typename boost::mpl::begin< boost::function_types::parameter_types<Function> >::type
-              , class To   = typename boost::mpl::end< boost::function_types::parameter_types<Function> >::type
-              >
-    struct invoker;
-
-    // deliver LLSD arguments one at a time
-    typedef boost::function<LLSD()> args_source;
-    // obtain args from an args_source to build param list and call target
-    // function
-    typedef boost::function<void(const args_source&)> invoker_function;
-
-    template <typename Function>
-    invoker_function make_invoker(Function f);
-    template <typename Method, typename InstanceGetter>
-    invoker_function make_invoker(Method f, const InstanceGetter& getter);
-    void addArrayParamsDispatchEntry(const std::string& name,
-                                     const std::string& desc,
-                                     const invoker_function& invoker,
-                                     LLSD::Integer arity);
-    void addMapParamsDispatchEntry(const std::string& name,
-                                   const std::string& desc,
-                                   const invoker_function& invoker,
-                                   const LLSD& params,
-                                   const LLSD& defaults);
-};
-
-/*****************************************************************************
-*   LLEventDispatcher template implementation details
-*****************************************************************************/
-// Step 3 of parameter analysis, the recursive case.
-template<typename Function, class From, class To>
-struct LLEventDispatcher::invoker
-{
-    template<typename T>
-    struct remove_cv_ref
-        : boost::remove_cv< typename boost::remove_reference<T>::type >
-    { };
-
-    // apply() accepts an arbitrary boost::fusion sequence as args. It
-    // examines the next parameter type in the parameter-types sequence
-    // bounded by From and To, obtains the next LLSD object from the passed
-    // args_source and constructs an LLSDParam of appropriate type to try
-    // to convert the value. It then recurs with the next parameter-types
-    // iterator, passing the args sequence thus far.
-    template<typename Args>
-    static inline
-    void apply(Function func, const args_source& argsrc, Args const & args)
-    {
-        typedef typename boost::mpl::deref<From>::type arg_type;
-        typedef typename boost::mpl::next<From>::type next_iter_type;
-        typedef typename remove_cv_ref<arg_type>::type plain_arg_type;
-
-        invoker<Function, next_iter_type, To>::apply
-        ( func, argsrc, boost::fusion::push_back(args, LLSDParam<plain_arg_type>(argsrc())));
-    }
-
-    // Special treatment for instance (first) parameter of a non-static member
-    // function. Accept the instance-getter callable, calling that to produce
-    // the first args value. Since we know we're at the top of the recursion
-    // chain, we need not also require a partial args sequence from our caller.
-    template <typename InstanceGetter>
-    static inline
-    void method_apply(Function func, const args_source& argsrc, const InstanceGetter& getter)
-    {
-        typedef typename boost::mpl::next<From>::type next_iter_type;
-
-        // Instead of grabbing the first item from argsrc and making an
-        // LLSDParam of it, call getter() and pass that as the instance param.
-        invoker<Function, next_iter_type, To>::apply
-        ( func, argsrc, boost::fusion::push_back(boost::fusion::nil(), boost::ref(getter())));
-    }
-};
-
-// Step 4 of parameter analysis, the leaf case. When the general
-// invoker<Function, From, To> logic has advanced From until it matches To,
-// the compiler will pick this template specialization.
-template<typename Function, class To>
-struct LLEventDispatcher::invoker<Function,To,To>
-{
-    // the argument list is complete, now call the function
-    template<typename Args>
-    static inline
-    void apply(Function func, const args_source&, Args const & args)
-    {
-        boost::fusion::invoke(func, args);
-    }
-};
-
-template<typename Function>
-typename boost::enable_if< boost::function_types::is_nonmember_callable_builtin<Function> >::type
-LLEventDispatcher::add(const std::string& name, const std::string& desc, Function f)
-{
-    // Construct an invoker_function, a callable accepting const args_source&.
-    // Add to DispatchMap an ArrayParamsDispatchEntry that will handle the
-    // caller's LLSD::Array.
-    addArrayParamsDispatchEntry(name, desc, make_invoker(f),
-                                boost::function_types::function_arity<Function>::value);
-}
-
-template<typename Method, typename InstanceGetter>
-typename boost::enable_if< boost::function_types::is_member_function_pointer<Method> >::type
-LLEventDispatcher::add(const std::string& name, const std::string& desc, Method f,
-                       const InstanceGetter& getter)
-{
-    // Subtract 1 from the compile-time arity because the getter takes care of
-    // the first parameter. We only need (arity - 1) additional arguments.
-    addArrayParamsDispatchEntry(name, desc, make_invoker(f, getter),
-                                boost::function_types::function_arity<Method>::value - 1);
-}
-
-template<typename Function>
-typename boost::enable_if< boost::function_types::is_nonmember_callable_builtin<Function> >::type
-LLEventDispatcher::add(const std::string& name, const std::string& desc, Function f,
-                       const LLSD& params, const LLSD& defaults)
-{
-    // See comments for previous is_nonmember_callable_builtin add().
-    addMapParamsDispatchEntry(name, desc, make_invoker(f), params, defaults);
-}
-
-template<typename Method, typename InstanceGetter>
-typename boost::enable_if< boost::function_types::is_member_function_pointer<Method> >::type
-LLEventDispatcher::add(const std::string& name, const std::string& desc, Method f,
-                       const InstanceGetter& getter,
-                       const LLSD& params, const LLSD& defaults)
-{
-    addMapParamsDispatchEntry(name, desc, make_invoker(f, getter), params, defaults);
-}
-
-template <typename Function>
-LLEventDispatcher::invoker_function
-LLEventDispatcher::make_invoker(Function f)
-{
-    // Step 1 of parameter analysis, the top of the recursion. Passing a
-    // suitable f (see add()'s enable_if condition) to this method causes it
-    // to infer the function type; specifying that function type to invoker<>
-    // causes it to fill in the begin/end MPL iterators over the function's
-    // list of parameter types.
-    // While normally invoker::apply() could infer its template type from the
-    // boost::fusion::nil parameter value, here we must be explicit since
-    // we're boost::bind()ing it rather than calling it directly.
-    return boost::bind(&invoker<Function>::template apply<boost::fusion::nil>,
-                       f,
-                       _1,
-                       boost::fusion::nil());
-}
-
-template <typename Method, typename InstanceGetter>
-LLEventDispatcher::invoker_function
-LLEventDispatcher::make_invoker(Method f, const InstanceGetter& getter)
-{
-    // Use invoker::method_apply() to treat the instance (first) arg specially.
-    return boost::bind(&invoker<Method>::template method_apply<InstanceGetter>,
-                       f,
-                       _1,
-                       getter);
-}
-
-/*****************************************************************************
-*   LLDispatchListener
-*****************************************************************************/
-/**
- * Bundle an LLEventPump and a listener with an LLEventDispatcher. A class
- * that contains (or derives from) LLDispatchListener need only specify the
- * LLEventPump name and dispatch key, and add() its methods. Incoming events
- * will automatically be dispatched.
- */
-class LL_COMMON_API LLDispatchListener: public LLEventDispatcher
-{
-public:
-    LLDispatchListener(const std::string& pumpname, const std::string& key);
-
-    std::string getPumpName() const { return mPump.getName(); }
-
-private:
-    bool process(const LLSD& event);
-
-    LLEventStream mPump;
-    LLTempBoundListener mBoundListener;
-};
-
-#endif /* ! defined(LL_LLEVENTDISPATCHER_H) */

indra/llcommon/lleventfilter.cpp

@@ -1,166 +0,0 @@
-/**
- * @file   lleventfilter.cpp
- * @author Nat Goodspeed
- * @date   2009-03-05
- * @brief  Implementation for lleventfilter.
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// Precompiled header
-#include "linden_common.h"
-// associated header
-#include "lleventfilter.h"
-// STL headers
-// std headers
-// external library headers
-#include <boost/bind.hpp>
-// other Linden headers
-#include "llerror.h"                // LL_ERRS
-#include "llsdutil.h"               // llsd_matches()
-
-LLEventFilter::LLEventFilter(LLEventPump& source, const std::string& name, bool tweak):
-    LLEventStream(name, tweak)
-{
-    source.listen(getName(), boost::bind(&LLEventFilter::post, this, _1));
-}
-
-LLEventMatching::LLEventMatching(const LLSD& pattern):
-    LLEventFilter("matching"),
-    mPattern(pattern)
-{
-}
-
-LLEventMatching::LLEventMatching(LLEventPump& source, const LLSD& pattern):
-    LLEventFilter(source, "matching"),
-    mPattern(pattern)
-{
-}
-
-bool LLEventMatching::post(const LLSD& event)
-{
-    if (! llsd_matches(mPattern, event).empty())
-        return false;
-
-    return LLEventStream::post(event);
-}
-
-LLEventTimeoutBase::LLEventTimeoutBase():
-    LLEventFilter("timeout")
-{
-}
-
-LLEventTimeoutBase::LLEventTimeoutBase(LLEventPump& source):
-    LLEventFilter(source, "timeout")
-{
-}
-
-void LLEventTimeoutBase::actionAfter(F32 seconds, const Action& action)
-{
-    setCountdown(seconds);
-    mAction = action;
-    if (! mMainloop.connected())
-    {
-        LLEventPump& mainloop(LLEventPumps::instance().obtain("mainloop"));
-        mMainloop = mainloop.listen(getName(), boost::bind(&LLEventTimeoutBase::tick, this, _1));
-    }
-}
-
-class ErrorAfter
-{
-public:
-    ErrorAfter(const std::string& message): mMessage(message) {}
-
-    void operator()()
-    {
-        LL_ERRS("LLEventTimeout") << mMessage << LL_ENDL;
-    }
-
-private:
-    std::string mMessage;
-};
-
-void LLEventTimeoutBase::errorAfter(F32 seconds, const std::string& message)
-{
-    actionAfter(seconds, ErrorAfter(message));
-}
-
-class EventAfter
-{
-public:
-    EventAfter(LLEventPump& pump, const LLSD& event):
-        mPump(pump),
-        mEvent(event)
-    {}
-
-    void operator()()
-    {
-        mPump.post(mEvent);
-    }
-
-private:
-    LLEventPump& mPump;
-    LLSD mEvent;
-};
-
-void LLEventTimeoutBase::eventAfter(F32 seconds, const LLSD& event)
-{
-    actionAfter(seconds, EventAfter(*this, event));
-}
-
-bool LLEventTimeoutBase::post(const LLSD& event)
-{
-    cancel();
-    return LLEventStream::post(event);
-}
-
-void LLEventTimeoutBase::cancel()
-{
-    mMainloop.disconnect();
-}
-
-bool LLEventTimeoutBase::tick(const LLSD&)
-{
-    if (countdownElapsed())
-    {
-        cancel();
-        mAction();
-    }
-    return false;                   // show event to other listeners
-}
-
-LLEventTimeout::LLEventTimeout() {}
-
-LLEventTimeout::LLEventTimeout(LLEventPump& source):
-    LLEventTimeoutBase(source)
-{
-}
-
-void LLEventTimeout::setCountdown(F32 seconds)
-{
-    mTimer.setTimerExpirySec(seconds);
-}
-
-bool LLEventTimeout::countdownElapsed() const
-{
-    return mTimer.hasExpired();
-}

indra/llcommon/lleventfilter.h

@@ -1,203 +0,0 @@
-/**
- * @file   lleventfilter.h
- * @author Nat Goodspeed
- * @date   2009-03-05
- * @brief  Define LLEventFilter: LLEventStream subclass with conditions
- * 
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if ! defined(LL_LLEVENTFILTER_H)
-#define LL_LLEVENTFILTER_H
-
-#include "llevents.h"
-#include "stdtypes.h"
-#include "lltimer.h"
-#include <boost/function.hpp>
-
-/**
- * Generic base class
- */
-class LL_COMMON_API LLEventFilter: public LLEventStream
-{
-public:
-    /// construct a standalone LLEventFilter
-    LLEventFilter(const std::string& name="filter", bool tweak=true):
-        LLEventStream(name, tweak)
-    {}
-    /// construct LLEventFilter and connect it to the specified LLEventPump
-    LLEventFilter(LLEventPump& source, const std::string& name="filter", bool tweak=true);
-
-    /// Post an event to all listeners
-    virtual bool post(const LLSD& event) = 0;
-};
-
-/**
- * Pass through only events matching a specified pattern
- */
-class LLEventMatching: public LLEventFilter
-{
-public:
-    /// Pass an LLSD map with keys and values the incoming event must match
-    LLEventMatching(const LLSD& pattern);
-    /// instantiate and connect
-    LLEventMatching(LLEventPump& source, const LLSD& pattern);
-
-    /// Only pass through events matching the pattern
-    virtual bool post(const LLSD& event);
-
-private:
-    LLSD mPattern;
-};
-
-/**
- * Wait for an event to be posted. If no such event arrives within a specified
- * time, take a specified action. See LLEventTimeout for production
- * implementation.
- *
- * @NOTE This is an abstract base class so that, for testing, we can use an
- * alternate "timer" that doesn't actually consume real time.
- */
-class LL_COMMON_API LLEventTimeoutBase: public LLEventFilter
-{
-public:
-    /// construct standalone
-    LLEventTimeoutBase();
-    /// construct and connect
-    LLEventTimeoutBase(LLEventPump& source);
-
-    /// Callable, can be constructed with boost::bind()
-    typedef boost::function<void()> Action;
-
-    /**
-     * Start countdown timer for the specified number of @a seconds. Forward
-     * all events. If any event arrives before timer expires, cancel timer. If
-     * no event arrives before timer expires, take specified @a action.
-     *
-     * This is a one-shot timer. Once it has either expired or been canceled,
-     * it is inert until another call to actionAfter().
-     *
-     * Calling actionAfter() while an existing timer is running cheaply
-     * replaces that original timer. Thus, a valid use case is to detect
-     * idleness of some event source by calling actionAfter() on each new
-     * event. A rapid sequence of events will keep the timer from expiring;
-     * the first gap in events longer than the specified timer will fire the
-     * specified Action.
-     *
-     * Any post() call cancels the timer. To be satisfied with only a
-     * particular event, chain on an LLEventMatching that only passes such
-     * events:
-     *
-     * @code
-     * event                                                 ultimate
-     * source ---> LLEventMatching ---> LLEventTimeout  ---> listener
-     * @endcode
-     *
-     * @NOTE
-     * The implementation relies on frequent events on the LLEventPump named
-     * "mainloop".
-     */
-    void actionAfter(F32 seconds, const Action& action);
-
-    /**
-     * Like actionAfter(), but where the desired Action is LL_ERRS
-     * termination. Pass the timeout time and the desired LL_ERRS @a message.
-     *
-     * This method is useful when, for instance, some async API guarantees an
-     * event, whether success or failure, within a stated time window.
-     * Instantiate an LLEventTimeout listening to that API and call
-     * errorAfter() on each async request with a timeout comfortably longer
-     * than the API's time guarantee (much longer than the anticipated
-     * "mainloop" granularity).
-     *
-     * Then if the async API breaks its promise, the program terminates with
-     * the specified LL_ERRS @a message. The client of the async API can
-     * therefore assume the guarantee is upheld.
-     *
-     * @NOTE
-     * errorAfter() is implemented in terms of actionAfter(), so all remarks
-     * about calling actionAfter() also apply to errorAfter().
-     */
-    void errorAfter(F32 seconds, const std::string& message);
-
-    /**
-     * Like actionAfter(), but where the desired Action is a particular event
-     * for all listeners. Pass the timeout time and the desired @a event data.
-     * 
-     * Suppose the timeout should only be satisfied by a particular event, but
-     * the ultimate listener must see all other incoming events as well, plus
-     * the timeout @a event if any:
-     * 
-     * @code
-     * some        LLEventMatching                           LLEventMatching
-     * event  ---> for particular  ---> LLEventTimeout  ---> for timeout
-     * source      event                                     event \
-     *       \                                                      \ ultimate
-     *        `-----------------------------------------------------> listener
-     * @endcode
-     * 
-     * Since a given listener can listen on more than one LLEventPump, we can
-     * set things up so it sees the set union of events from LLEventTimeout
-     * and the original event source. However, as LLEventTimeout passes
-     * through all incoming events, the "particular event" that satisfies the
-     * left LLEventMatching would reach the ultimate listener twice. So we add
-     * an LLEventMatching that only passes timeout events.
-     *
-     * @NOTE
-     * eventAfter() is implemented in terms of actionAfter(), so all remarks
-     * about calling actionAfter() also apply to eventAfter().
-     */
-    void eventAfter(F32 seconds, const LLSD& event);
-
-    /// Pass event through, canceling the countdown timer
-    virtual bool post(const LLSD& event);
-
-    /// Cancel timer without event
-    void cancel();
-
-protected:
-    virtual void setCountdown(F32 seconds) = 0;
-    virtual bool countdownElapsed() const = 0;
-
-private:
-    bool tick(const LLSD&);
-
-    LLBoundListener mMainloop;
-    Action mAction;
-};
-
-/// Production implementation of LLEventTimoutBase
-class LL_COMMON_API LLEventTimeout: public LLEventTimeoutBase
-{
-public:
-    LLEventTimeout();
-    LLEventTimeout(LLEventPump& source);
-
-protected:
-    virtual void setCountdown(F32 seconds);
-    virtual bool countdownElapsed() const;
-
-private:
-    LLTimer mTimer;
-};
-
-#endif /* ! defined(LL_LLEVENTFILTER_H) */

indra/llcommon/llevents.cpp

@@ -1,628 +0,0 @@
-/**
- * @file   llevents.cpp
- * @author Nat Goodspeed
- * @date   2008-09-12
- * @brief  Implementation for llevents.
- * 
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// Precompiled header
-#include "linden_common.h"
-
-#if LL_WINDOWS
-#pragma warning (disable : 4675) // "resolved by ADL" -- just as I want!
-#endif
-
-// associated header
-#include "llevents.h"
-// STL headers
-#include <set>
-#include <sstream>
-#include <algorithm>
-// std headers
-#include <typeinfo>
-#include <cassert>
-#include <cmath>
-#include <cctype>
-// external library headers
-#include <boost/range/iterator_range.hpp>
-#if LL_WINDOWS
-#pragma warning (push)
-#pragma warning (disable : 4701) // compiler thinks might use uninitialized var, but no
-#endif
-#include <boost/lexical_cast.hpp>
-#if LL_WINDOWS
-#pragma warning (pop)
-#endif
-// other Linden headers
-#include "stringize.h"
-#include "llerror.h"
-#include "llsdutil.h"
-#if LL_MSVC
-#pragma warning (disable : 4702)
-#endif
-
-/*****************************************************************************
-*   queue_names: specify LLEventPump names that should be instantiated as
-*   LLEventQueue
-*****************************************************************************/
-/**
- * At present, we recognize particular requested LLEventPump names as needing
- * LLEventQueues. Later on we'll migrate this information to an external
- * configuration file.
- */
-const char* queue_names[] =
-{
-    "placeholder - replace with first real name string"
-};
-
-/*****************************************************************************
-*   If there's a "mainloop" pump, listen on that to flush all LLEventQueues
-*****************************************************************************/
-struct RegisterFlush : public LLEventTrackable
-{
-    RegisterFlush():
-        pumps(LLEventPumps::instance())
-    {
-        pumps.obtain("mainloop").listen("flushLLEventQueues", boost::bind(&RegisterFlush::flush, this, _1));
-    }
-    bool flush(const LLSD&)
-    {
-        pumps.flush();
-        return false;
-    }
-    ~RegisterFlush()
-    {
-        // LLEventTrackable handles stopListening for us.
-    }
-    LLEventPumps& pumps;
-};
-static RegisterFlush registerFlush;
-
-/*****************************************************************************
-*   LLEventPumps
-*****************************************************************************/
-LLEventPumps::LLEventPumps():
-    // Until we migrate this information to an external config file,
-    // initialize mQueueNames from the static queue_names array.
-    mQueueNames(boost::begin(queue_names), boost::end(queue_names))
-{
-}
-
-LLEventPump& LLEventPumps::obtain(const std::string& name)
-{
-    PumpMap::iterator found = mPumpMap.find(name);
-    if (found != mPumpMap.end())
-    {
-        // Here we already have an LLEventPump instance with the requested
-        // name.
-        return *found->second;
-    }
-    // Here we must instantiate an LLEventPump subclass. 
-    LLEventPump* newInstance;
-    // Should this name be an LLEventQueue?
-    PumpNames::const_iterator nfound = mQueueNames.find(name);
-    if (nfound != mQueueNames.end())
-        newInstance = new LLEventQueue(name);
-    else
-        newInstance = new LLEventStream(name);
-    // LLEventPump's constructor implicitly registers each new instance in
-    // mPumpMap. But remember that we instantiated it (in mOurPumps) so we'll
-    // delete it later.
-    mOurPumps.insert(newInstance);
-    return *newInstance;
-}
-
-void LLEventPumps::flush()
-{
-    // Flush every known LLEventPump instance. Leave it up to each instance to
-    // decide what to do with the flush() call.
-    for (PumpMap::iterator pmi = mPumpMap.begin(), pmend = mPumpMap.end(); pmi != pmend; ++pmi)
-    {
-        pmi->second->flush();
-    }
-}
-
-void LLEventPumps::reset()
-{
-    // Reset every known LLEventPump instance. Leave it up to each instance to
-    // decide what to do with the reset() call.
-    for (PumpMap::iterator pmi = mPumpMap.begin(), pmend = mPumpMap.end(); pmi != pmend; ++pmi)
-    {
-        pmi->second->reset();
-    }
-}
-
-std::string LLEventPumps::registerNew(const LLEventPump& pump, const std::string& name, bool tweak)
-{
-    std::pair<PumpMap::iterator, bool> inserted =
-        mPumpMap.insert(PumpMap::value_type(name, const_cast<LLEventPump*>(&pump)));
-    // If the insert worked, then the name is unique; return that.
-    if (inserted.second)
-        return name;
-    // Here the new entry was NOT inserted, and therefore name isn't unique.
-    // Unless we're permitted to tweak it, that's Bad.
-    if (! tweak)
-    {
-        throw LLEventPump::DupPumpName(std::string("Duplicate LLEventPump name '") + name + "'");
-    }
-    // The passed name isn't unique, but we're permitted to tweak it. Find the
-    // first decimal-integer suffix not already taken. The insert() attempt
-    // above will have set inserted.first to the iterator of the existing
-    // entry by that name. Starting there, walk forward until we reach an
-    // entry that doesn't start with 'name'. For each entry consisting of name
-    // + integer suffix, capture the integer suffix in a set. Use a set
-    // because we're going to encounter string suffixes in the order: name1,
-    // name10, name11, name2, ... Walking those possibilities in that order
-    // isn't convenient to detect the first available "hole."
-    std::set<int> suffixes;
-    PumpMap::iterator pmi(inserted.first), pmend(mPumpMap.end());
-    // We already know inserted.first references the existing entry with
-    // 'name' as the key; skip that one and start with the next.
-    while (++pmi != pmend)
-    {
-        if (pmi->first.substr(0, name.length()) != name)
-        {
-            // Found the first entry beyond the entries starting with 'name':
-            // stop looping.
-            break;
-        }
-        // Here we're looking at an entry that starts with 'name'. Is the rest
-        // of it an integer?
-        // Dubious (?) assumption: in the local character set, decimal digits
-        // are in increasing order such that '9' is the last of them. This
-        // test deals with 'name' values such as 'a', where there might be a
-        // very large number of entries starting with 'a' whose suffixes
-        // aren't integers. A secondary assumption is that digit characters
-        // precede most common name characters (true in ASCII, false in
-        // EBCDIC). The test below is correct either way, but it's worth more
-        // if the assumption holds.
-        if (pmi->first[name.length()] > '9')
-            break;
-        // It should be cheaper to detect that we're not looking at a digit
-        // character -- and therefore the suffix can't possibly be an integer
-        // -- than to attempt the lexical_cast and catch the exception.
-        if (! std::isdigit(pmi->first[name.length()]))
-            continue;
-        // Okay, the first character of the suffix is a digit, it's worth at
-        // least attempting to convert to int.
-        try
-        {
-            suffixes.insert(boost::lexical_cast<int>(pmi->first.substr(name.length())));
-        }
-        catch (const boost::bad_lexical_cast&)
-        {
-            // If the rest of pmi->first isn't an int, just ignore it.
-        }
-    }
-    // Here we've accumulated in 'suffixes' all existing int suffixes of the
-    // entries starting with 'name'. Find the first unused one.
-    int suffix = 1;
-    for ( ; suffixes.find(suffix) != suffixes.end(); ++suffix)
-        ;
-    // Here 'suffix' is not in 'suffixes'. Construct a new name based on that
-    // suffix, insert it and return it.
-    std::ostringstream out;
-    out << name << suffix;
-    return registerNew(pump, out.str(), tweak);
-}
-
-void LLEventPumps::unregister(const LLEventPump& pump)
-{
-    // Remove this instance from mPumpMap
-    PumpMap::iterator found = mPumpMap.find(pump.getName());
-    if (found != mPumpMap.end())
-    {
-        mPumpMap.erase(found);
-    }
-    // If this instance is one we created, also remove it from mOurPumps so we
-    // won't try again to delete it later!
-    PumpSet::iterator psfound = mOurPumps.find(const_cast<LLEventPump*>(&pump));
-    if (psfound != mOurPumps.end())
-    {
-        mOurPumps.erase(psfound);
-    }
-}
-
-//static
-bool LLEventPumps::sDeleted;
-
-//static
-void LLEventPumps::maybe_unregister(const LLEventPump& pump)
-{
-	if (!sDeleted)
-	{
-		LLEventPumps::instance().unregister(pump);
-	}
-}
-
-LLEventPumps::~LLEventPumps()
-{
-    // Deleting an LLEventPump calls its destructor, which calls maybe_unregister(),
-    // which would try to remove that LLEventPump instance from a NEWLY created LLEventPumps
-    // singleton (as we're already being destructed). Therefore, mark that we're not
-    // home anymore... --Aleric
-    sDeleted = true;
-
-    // Subsequently we can delete every LLEventPump we instantiated (via obtain()).
-	// We're not clearing mPumpMap or mOurPumps here... their destructors will.
-    for (LLEventPumps::PumpSet::iterator pump = mOurPumps.begin(); pump != mOurPumps.end(); ++pump)
-    {
-        delete *pump;
-    }
-}
-
-/*****************************************************************************
-*   LLEventPump
-*****************************************************************************/
-#if LL_WINDOWS
-#pragma warning (push)
-#pragma warning (disable : 4355) // 'this' used in initializer list: yes, intentionally
-#endif
-
-LLEventPump::LLEventPump(const std::string& name, bool tweak):
-    // Register every new instance with LLEventPumps
-    mName(LLEventPumps::instance().registerNew(*this, name, tweak)),
-    mSignal(new LLStandardSignal()),
-    mEnabled(true)
-{}
-
-#if LL_WINDOWS
-#pragma warning (pop)
-#endif
-
-LLEventPump::~LLEventPump()
-{
-    // Unregister this doomed instance from LLEventPumps
-    LLEventPumps::maybe_unregister(*this);
-}
-
-// static data member
-const LLEventPump::NameList LLEventPump::empty;
-
-std::string LLEventPump::inventName(const std::string& pfx)
-{
-    static long suffix = 0;
-    return STRINGIZE(pfx << suffix++);
-}
-
-void LLEventPump::reset()
-{
-    mSignal.reset();
-    mConnections.clear();
-    //mDeps.clear();
-}
-
-LLBoundListener LLEventPump::listen_impl(const std::string& name, const LLEventListener& listener,
-                                         const NameList& after,
-                                         const NameList& before)
-{
-    // Check for duplicate name before connecting listener to mSignal
-    ConnectionMap::const_iterator found = mConnections.find(name);
-    // In some cases the user might disconnect a connection explicitly -- or
-    // might use LLEventTrackable to disconnect implicitly. Either way, we can
-    // end up retaining in mConnections a zombie connection object that's
-    // already been disconnected. Such a connection object can't be
-    // reconnected -- nor, in the case of LLEventTrackable, would we want to
-    // try, since disconnection happens with the destruction of the listener
-    // object. That means it's safe to overwrite a disconnected connection
-    // object with the new one we're attempting. The case we want to prevent
-    // is only when the existing connection object is still connected.
-    if (found != mConnections.end() && found->second.connected())
-    {
-        throw DupListenerName(std::string("Attempt to register duplicate listener name '") + name +
-                              "' on " + typeid(*this).name() + " '" + getName() + "'");
-    }
-    // Okay, name is unique, try to reconcile its dependencies. Specify a new
-    // "node" value that we never use for an mSignal placement; we'll fix it
-    // later.
-    DependencyMap::node_type& newNode = mDeps.add(name, -1.0, after, before);
-    // What if this listener has been added, removed and re-added? In that
-    // case newNode already has a non-negative value because we never remove a
-    // listener from mDeps. But keep processing uniformly anyway in case the
-    // listener was added back with different dependencies. Then mDeps.sort()
-    // would put it in a different position, and the old newNode placement
-    // value would be wrong, so we'd have to reassign it anyway. Trust that
-    // re-adding a listener with the same dependencies is the trivial case for
-    // mDeps.sort(): it can just replay its cache.
-    DependencyMap::sorted_range sorted_range;
-    try
-    {
-        // Can we pick an order that works including this new entry?
-        sorted_range = mDeps.sort();
-    }
-    catch (const DependencyMap::Cycle& e)
-    {
-        // No: the new node's after/before dependencies have made mDeps
-        // unsortable. If we leave the new node in mDeps, it will continue
-        // to screw up all future attempts to sort()! Pull it out.
-        mDeps.remove(name);
-        throw Cycle(std::string("New listener '") + name + "' on " + typeid(*this).name() +
-                    " '" + getName() + "' would cause cycle: " + e.what());
-    }
-    // Walk the list to verify that we haven't changed the order.
-    float previous = 0.0, myprev = 0.0;
-    DependencyMap::sorted_iterator mydmi = sorted_range.end(); // need this visible after loop
-    for (DependencyMap::sorted_iterator dmi = sorted_range.begin();
-         dmi != sorted_range.end(); ++dmi)
-    {
-        // Since we've added the new entry with an invalid placement,
-        // recognize it and skip it.
-        if (dmi->first == name)
-        {
-            // Remember the iterator belonging to our new node, and which
-            // placement value was 'previous' at that point.
-            mydmi = dmi;
-            myprev = previous;
-            continue;
-        }
-        // If the new node has rearranged the existing nodes, we'll find
-        // that their placement values are no longer in increasing order.
-        if (dmi->second < previous)
-        {
-            // This is another scenario in which we'd better back out the
-            // newly-added node from mDeps -- but don't do it yet, we want to
-            // traverse the existing mDeps to report on it!
-            // Describe the change to the order of our listeners. Copy
-            // everything but the newest listener to a vector we can sort to
-            // obtain the old order.
-            typedef std::vector< std::pair<float, std::string> > SortNameList;
-            SortNameList sortnames;
-            for (DependencyMap::sorted_iterator cdmi(sorted_range.begin()), cdmend(sorted_range.end());
-                 cdmi != cdmend; ++cdmi)
-            {
-                if (cdmi->first != name)
-                {
-                    sortnames.push_back(SortNameList::value_type(cdmi->second, cdmi->first));
-                }
-            }
-            std::sort(sortnames.begin(), sortnames.end());
-            std::ostringstream out;
-            out << "New listener '" << name << "' on " << typeid(*this).name() << " '" << getName()
-                << "' would move previous listener '" << dmi->first << "'\nwas: ";
-            SortNameList::const_iterator sni(sortnames.begin()), snend(sortnames.end());
-            if (sni != snend)
-            {
-                out << sni->second;
-                while (++sni != snend)
-                {
-                    out << ", " << sni->second;
-                }
-            }
-            out << "\nnow: ";
-            DependencyMap::sorted_iterator ddmi(sorted_range.begin()), ddmend(sorted_range.end());
-            if (ddmi != ddmend)
-            {
-                out << ddmi->first;
-                while (++ddmi != ddmend)
-                {
-                    out << ", " << ddmi->first;
-                }
-            }
-            // NOW remove the offending listener node.
-            mDeps.remove(name);
-            // Having constructed a description of the order change, inform caller.
-            throw OrderChange(out.str());
-        }
-        // This node becomes the previous one.
-        previous = dmi->second;
-    }
-    // We just got done with a successful mDeps.add(name, ...) call. We'd
-    // better have found 'name' somewhere in that sorted list!
-    assert(mydmi != sorted_range.end());
-    // Four cases:
-    // 0. name is the only entry: placement 1.0
-    // 1. name is the first of several entries: placement (next placement)/2
-    // 2. name is between two other entries: placement (myprev + (next placement))/2
-    // 3. name is the last entry: placement ceil(myprev) + 1.0
-    // Since we've cleverly arranged for myprev to be 0.0 if name is the
-    // first entry, this folds down to two cases. Case 1 is subsumed by
-    // case 2, and case 0 is subsumed by case 3. So we need only handle
-    // cases 2 and 3, which means we need only detect whether name is the
-    // last entry. Increment mydmi to see if there's anything beyond.
-    if (++mydmi != sorted_range.end())
-    {
-        // The new node isn't last. Place it between the previous node and
-        // the successor.
-        newNode = (myprev + mydmi->second)/2.0;
-    }
-    else
-    {
-        // The new node is last. Bump myprev up to the next integer, add
-        // 1.0 and use that.
-        newNode = std::ceil(myprev) + 1.0;
-    }
-    // Now that newNode has a value that places it appropriately in mSignal,
-    // connect it.
-    LLBoundListener bound = mSignal->connect(newNode, listener);
-    mConnections[name] = bound;
-    return bound;
-}
-
-LLBoundListener LLEventPump::getListener(const std::string& name) const
-{
-    ConnectionMap::const_iterator found = mConnections.find(name);
-    if (found != mConnections.end())
-    {
-        return found->second;
-    }
-    // not found, return dummy LLBoundListener
-    return LLBoundListener();
-}
-
-void LLEventPump::stopListening(const std::string& name)
-{
-    ConnectionMap::iterator found = mConnections.find(name);
-    if (found != mConnections.end())
-    {
-        found->second.disconnect();
-        mConnections.erase(found);
-    }
-    // We intentionally do NOT remove this name from mDeps. It may happen that
-    // the same listener with the same name and dependencies will jump on and
-    // off this LLEventPump repeatedly. Keeping a cache of dependencies will
-    // avoid a new dependency sort in such cases.
-}
-
-/*****************************************************************************
-*   LLEventStream
-*****************************************************************************/
-bool LLEventStream::post(const LLSD& event)
-{
-    if (! mEnabled || !mSignal)
-    {
-        return false;
-    }
-    // NOTE NOTE NOTE: Any new access to member data beyond this point should
-    // cause us to move our LLStandardSignal object to a pimpl class along
-    // with said member data. Then the local shared_ptr will preserve both.
-
-    // DEV-43463: capture a local copy of mSignal. We've turned up a
-    // cross-coroutine scenario (described in the Jira) in which this post()
-    // call could end up destroying 'this', the LLEventPump subclass instance
-    // containing mSignal, during the call through *mSignal. So -- capture a
-    // *stack* instance of the shared_ptr, ensuring that our heap
-    // LLStandardSignal object will live at least until post() returns, even
-    // if 'this' gets destroyed during the call.
-    boost::shared_ptr<LLStandardSignal> signal(mSignal);
-    // Let caller know if any one listener handled the event. This is mostly
-    // useful when using LLEventStream as a listener for an upstream
-    // LLEventPump.
-    return (*signal)(event);
-}
-
-/*****************************************************************************
-*   LLEventQueue
-*****************************************************************************/
-bool LLEventQueue::post(const LLSD& event)
-{
-    if (mEnabled)
-    {
-        // Defer sending this event by queueing it until flush()
-        mEventQueue.push_back(event);
-    }
-    // Unconditionally return false. We won't know until flush() whether a
-    // listener claims to have handled the event -- meanwhile, don't block
-    // other listeners.
-    return false;
-}
-
-void LLEventQueue::flush()
-{
-	if(!mSignal) return;
-		
-    // Consider the case when a given listener on this LLEventQueue posts yet
-    // another event on the same queue. If we loop over mEventQueue directly,
-    // we'll end up processing all those events during the same flush() call
-    // -- rather like an EventStream. Instead, copy mEventQueue and clear it,
-    // so that any new events posted to this LLEventQueue during flush() will
-    // be processed in the *next* flush() call.
-    EventQueue queue(mEventQueue);
-    mEventQueue.clear();
-    // NOTE NOTE NOTE: Any new access to member data beyond this point should
-    // cause us to move our LLStandardSignal object to a pimpl class along
-    // with said member data. Then the local shared_ptr will preserve both.
-
-    // DEV-43463: capture a local copy of mSignal. See LLEventStream::post()
-    // for detailed comments.
-    boost::shared_ptr<LLStandardSignal> signal(mSignal);
-    for ( ; ! queue.empty(); queue.pop_front())
-    {
-        (*signal)(queue.front());
-    }
-}
-
-/*****************************************************************************
-*   LLListenerOrPumpName
-*****************************************************************************/
-LLListenerOrPumpName::LLListenerOrPumpName(const std::string& pumpname):
-    // Look up the specified pumpname, and bind its post() method as our listener
-    mListener(boost::bind(&LLEventPump::post,
-                          boost::ref(LLEventPumps::instance().obtain(pumpname)),
-                          _1))
-{
-}
-
-LLListenerOrPumpName::LLListenerOrPumpName(const char* pumpname):
-    // Look up the specified pumpname, and bind its post() method as our listener
-    mListener(boost::bind(&LLEventPump::post,
-                          boost::ref(LLEventPumps::instance().obtain(pumpname)),
-                          _1))
-{
-}
-
-bool LLListenerOrPumpName::operator()(const LLSD& event) const
-{
-    if (! mListener)
-    {
-        throw Empty("attempting to call uninitialized");
-    }
-    return (*mListener)(event);
-}
-
-void LLReqID::stamp(LLSD& response) const
-{
-    if (! (response.isUndefined() || response.isMap()))
-    {
-        // If 'response' was previously completely empty, it's okay to
-        // turn it into a map. If it was already a map, then it should be
-        // okay to add a key. But if it was anything else (e.g. a scalar),
-        // assigning a ["reqid"] key will DISCARD the previous value,
-        // replacing it with a map. That would be Bad.
-        LL_INFOS("LLReqID") << "stamp(" << mReqid << ") leaving non-map response unmodified: "
-                            << response << LL_ENDL;
-        return;
-    }
-    LLSD oldReqid(response["reqid"]);
-    if (! (oldReqid.isUndefined() || llsd_equals(oldReqid, mReqid)))
-    {
-        LL_INFOS("LLReqID") << "stamp(" << mReqid << ") preserving existing [\"reqid\"] value "
-                            << oldReqid << " in response: " << response << LL_ENDL;
-        return;
-    }
-    response["reqid"] = mReqid;
-}
-
-bool sendReply(const LLSD& reply, const LLSD& request, const std::string& replyKey)
-{
-    // If the original request has no value for replyKey, it's pointless to
-    // construct or send a reply event: on which LLEventPump should we send
-    // it? Allow that to be optional: if the caller wants to require replyKey,
-    // it can so specify when registering the operation method.
-    if (! request.has(replyKey))
-    {
-        return false;
-    }
-
-    // Here the request definitely contains replyKey; reasonable to proceed.
-
-    // Copy 'reply' to modify it.
-    LLSD newreply(reply);
-    // Get the ["reqid"] element from request
-    LLReqID reqID(request);
-    // and copy it to 'newreply'.
-    reqID.stamp(newreply);
-    // Send reply on LLEventPump named in request[replyKey]. Don't forget to
-    // send the modified 'newreply' instead of the original 'reply'.
-    return LLEventPumps::instance().obtain(request[replyKey]).post(newreply);
-}

indra/llcommon/llfasttimer.cpp

@@ -0,0 +1,135 @@
+/** 
+ * @file llfasttimer.cpp
+ * @brief Implementation of the fast timer.
+ *
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llfasttimer.h"
+#include "llmemory.h"
+#include "llprocessor.h"
+
+#if LL_WINDOWS
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+#include "lltimer.h"
+
+//////////////////////////////////////////////////////////////////////////////
+// statics
+
+LLFastTimer::EFastTimerType LLFastTimer::sCurType = LLFastTimer::FTM_OTHER;
+int LLFastTimer::sCurDepth = 0;
+U64 LLFastTimer::sStart[LLFastTimer::FTM_MAX_DEPTH];
+U64 LLFastTimer::sCounter[LLFastTimer::FTM_NUM_TYPES];
+U64 LLFastTimer::sCountHistory[LLFastTimer::FTM_HISTORY_NUM][LLFastTimer::FTM_NUM_TYPES];
+U64 LLFastTimer::sCountAverage[LLFastTimer::FTM_NUM_TYPES];
+U64 LLFastTimer::sCalls[LLFastTimer::FTM_NUM_TYPES];
+U64 LLFastTimer::sCallHistory[LLFastTimer::FTM_HISTORY_NUM][LLFastTimer::FTM_NUM_TYPES];
+U64 LLFastTimer::sCallAverage[LLFastTimer::FTM_NUM_TYPES];
+S32 LLFastTimer::sCurFrameIndex = -1;
+S32 LLFastTimer::sLastFrameIndex = -1;
+int LLFastTimer::sPauseHistory = 0;
+int LLFastTimer::sResetHistory = 0;
+
+U64 LLFastTimer::sClockResolution = calc_clock_frequency(50U);	// Resolution of get_clock_count()
+
+U64 LLFastTimer::countsPerSecond() // counts per second for the *32-bit* timer
+{
+	return sClockResolution >> 8;
+}
+
+void LLFastTimer::reset()
+{
+	countsPerSecond(); // good place to calculate clock frequency
+	
+	if (sCurDepth != 0)
+	{
+		llerrs << "LLFastTimer::Reset() when sCurDepth != 0" << llendl;
+	}
+	if (sPauseHistory)
+	{
+		sResetHistory = 1;
+	}
+	else if (sResetHistory)
+	{
+		sCurFrameIndex = -1;
+		sResetHistory = 0;
+	}
+	else if (sCurFrameIndex >= 0)
+	{
+		int hidx = sCurFrameIndex % FTM_HISTORY_NUM;
+		for (S32 i=0; i<FTM_NUM_TYPES; i++)
+		{
+			sCountHistory[hidx][i] = sCounter[i];
+			sCountAverage[i] = (sCountAverage[i]*sCurFrameIndex + sCounter[i]) / (sCurFrameIndex+1);
+			sCallHistory[hidx][i] = sCalls[i];
+			sCallAverage[i] = (sCallAverage[i]*sCurFrameIndex + sCalls[i]) / (sCurFrameIndex+1);
+		}
+		sLastFrameIndex = sCurFrameIndex;
+	}
+	else
+	{
+		for (S32 i=0; i<FTM_NUM_TYPES; i++)
+		{
+			sCountAverage[i] = 0;
+			sCallAverage[i] = 0;
+		}
+	}
+	
+	sCurFrameIndex++;
+	
+	for (S32 i=0; i<FTM_NUM_TYPES; i++)
+	{
+		sCounter[i] = 0;
+		sCalls[i] = 0;
+	}
+	sCurDepth = 0;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Important note: These implementations must be FAST!
+//
+
+// shift off lower 8 bits for lower resolution but longer term timing
+// on 1Ghz machine, a 32-bit word will hold ~1000 seconds of timing
+
+//LL_COMMON_API U64 get_clock_count(); // in lltimer.cpp
+// On windows these use QueryPerformanceCounter, which is arguably fine and also works on amd architectures.
+U32 LLFastTimer::getCPUClockCount32()
+{
+	return get_clock_count() >> 8;
+}
+
+U64 LLFastTimer::getCPUClockCount64()
+{
+	return get_clock_count();
+}

indra/llcommon/llfasttimer.h

@@ -1,35 +1,306 @@
-/**
+/** 
  * @file llfasttimer.h
- * @brief Inline implementations of fast timers.
+ * @brief Declaration of a fast timer.
  *
- * $LicenseInfo:firstyear=2004&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2004&license=viewergpl$
+ * 
+ * Copyright (c) 2004-2009, Linden Research, Inc.
+ * 
  * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
  * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
  * $/LicenseInfo$
  */
 
-#ifndef LL_FASTTIMER_H
-#define LL_FASTTIMER_H
+#ifndef LL_LLFASTTIMER_H
+#define LL_LLFASTTIMER_H
 
-// Implementation of getCPUClockCount32() and getCPUClockCount64 are now in llfastertimer_class.cpp.
+#define FAST_TIMER_ON 1
+
+
+class LL_COMMON_API LLFastTimer
+{
+public:
+	enum EFastTimerType
+	{
+		// high level
+		FTM_FRAME,
+		FTM_UPDATE,
+		FTM_RENDER,
+		FTM_SWAP,
+		FTM_CLIENT_COPY,
+		FTM_IDLE,
+		FTM_SLEEP,
+
+		// general timers
+		FT_STRING_FORMAT,
+
+		// common messaging components
+		FTM_PUMP,
+		FTM_CURL,
+		FTM_PUMPIO,
+		
+		// common simulation components
+		FTM_UPDATE_ANIMATION,
+		FTM_UPDATE_TERRAIN,
+		FTM_UPDATE_PRIMITIVES,
+		FTM_UPDATE_PARTICLES,
+		FTM_SIMULATE_PARTICLES,
+		FTM_UPDATE_SKY,
+		FTM_UPDATE_TEXTURES,
+		FTM_UPDATE_WLPARAM,
+		FTM_UPDATE_WATER,
+		FTM_UPDATE_CLOUDS,
+		FTM_UPDATE_GRASS,
+		FTM_UPDATE_TREE,
+		FTM_UPDATE_AVATAR,
+		FTM_UPDATE_RIGGED_VOLUME,
+		FTM_SKIN_RIGGED,
+		FTM_RIGGED_OCTREE,
+
+		// common render components
+		FTM_SHADOW_GEOMETRY,
+		FTM_SHADOW_RENDER,
+		FTM_SHADOW_TERRAIN,
+		FTM_SHADOW_AVATAR,
+		FTM_SHADOW_SIMPLE,
+		FTM_SHADOW_ALPHA,
+		FTM_SHADOW_TREE,
+		
+		FTM_RENDER_GEOMETRY,
+		 FTM_RENDER_TERRAIN,
+		 FTM_RENDER_SIMPLE,
+		 FTM_RENDER_FULLBRIGHT,
+		 FTM_RENDER_GLOW,
+		 FTM_RENDER_GRASS,
+		 FTM_RENDER_INVISIBLE,
+		 FTM_RENDER_SHINY,
+		 FTM_RENDER_BUMP,
+		 FTM_RENDER_TREES,
+		 FTM_RENDER_CHARACTERS,
+		 FTM_RENDER_OCCLUSION,
+		 FTM_RENDER_ALPHA,
+         FTM_RENDER_CLOUDS,
+		 FTM_RENDER_HUD,
+		 FTM_RENDER_PARTICLES,
+		 FTM_RENDER_WATER,
+		 FTM_RENDER_WL_SKY,
+		 FTM_RENDER_FAKE_VBO_UPDATE,
+		FTM_RENDER_TIMER,
+		FTM_RENDER_UI,
+		FTM_RENDER_BLOOM,
+			FTM_RENDER_BLOOM_FBO,		
+		FTM_RENDER_FONTS,
+
+		// deferred rendering
+		FTM_RENDER_DEFERRED,
+		 FTM_BIND_DEFERRED,
+		 FTM_SUN_SHADOW,
+		 FTM_SOFTEN_SHADOW,
+		 FTM_EDGE_DETECTION,
+		 FTM_GI_TRACE,
+		 FTM_GI_GATHER,
+		 FTM_ATMOSPHERICS,
+		 FTM_LOCAL_LIGHTS,
+		 FTM_FULLSCREEN_LIGHTS,
+		 FTM_PROJECTORS,
+		 FTM_POST,
+
+		 FTM_VISIBLE_CLOUD,
+
+		// newview specific
+		FTM_MESSAGES,
+		FTM_MOUSEHANDLER,
+		FTM_KEYHANDLER,
+		FTM_REBUILD,
+		FTM_STATESORT,
+		FTM_STATESORT_DRAWABLE,
+		FTM_STATESORT_POSTSORT,
+		FTM_MESH_UPDATE,
+		FTM_MESH_LOCK1,
+		FTM_MESH_LOCK2,
+		FTM_LOAD_MESH_LOD,
+		FTM_REBUILD_VBO,
+		FTM_REBUILD_VOLUME_VB,
+		FTM_FACE_GET_GEOM,
+		FTM_FACE_GEOM_POSITION,
+		FTM_FACE_GEOM_NORMAL,
+		FTM_FACE_GEOM_TEXTURE,
+		FTM_FACE_GEOM_COLOR,
+		FTM_FACE_GEOM_EMISSIVE,
+		FTM_FACE_GEOM_WEIGHTS,
+		FTM_FACE_GEOM_BINORMAL,
+		FTM_FACE_GEOM_INDEX,
+		FTM_REBUILD_BRIDGE_VB,
+		FTM_REBUILD_HUD_VB,
+		FTM_REBUILD_TERRAIN_VB,
+		FTM_REBUILD_WATER_VB,
+		FTM_REBUILD_TREE_VB,
+		FTM_REBUILD_PARTICLE_VB,
+		FTM_REBUILD_CLOUD_VB,
+		FTM_REBUILD_GRASS_VB,
+		FTM_REBUILD_NONE_VB,
+		FTM_REBUILD_OCCLUSION_VB,
+		FTM_POOLS,
+		FTM_POOLRENDER,
+		FTM_IDLE_CB,
+		FTM_WORLD_UPDATE,
+		FTM_UPDATE_MOVE,
+		FTM_OCTREE_BALANCE,
+		FTM_UPDATE_LIGHTS,
+		FTM_CULL,
+		FTM_CULL_REBOUND,
+		FTM_FRUSTUM_CULL,
+		FTM_GEO_UPDATE,
+		FTM_GEO_RESERVE,
+		FTM_GEO_LIGHT,
+		FTM_GEO_SHADOW,
+		FTM_GEO_SKY,
+		FTM_GEN_VOLUME,
+		FTM_GEN_TRIANGLES,
+		FTM_GEN_FLEX,
+		FTM_AUDIO_UPDATE,
+		FTM_RESET_DRAWORDER,
+		FTM_OBJECTLIST_UPDATE,
+		FTM_AVATAR_UPDATE,
+		FTM_JOINT_UPDATE,
+		FTM_ATTACHMENT_UPDATE,
+		FTM_LOD_UPDATE,
+		FTM_REGION_UPDATE,
+		FTM_CLEANUP,
+		FTM_NETWORK,
+		FTM_IDLE_NETWORK,
+		FTM_CREATE_OBJECT,
+		FTM_LOAD_AVATAR,
+		FTM_PROCESS_MESSAGES,
+		FTM_PROCESS_OBJECTS,
+		FTM_PROCESS_IMAGES,
+		FTM_IMAGE_UPDATE,
+		FTM_IMAGE_CREATE,
+		FTM_IMAGE_DECODE,
+		FTM_IMAGE_READBACK,
+		FTM_IMAGE_MARK_DIRTY,
+		FTM_PIPELINE,
+		FTM_VFILE_WAIT,
+		FTM_FLEXIBLE_UPDATE,
+		FTM_OCCLUSION_READBACK,
+		FTM_HUD_EFFECTS,
+		FTM_HUD_UPDATE,
+		FTM_INVENTORY,
+		FTM_AUTO_SELECT,
+		FTM_ARRANGE,
+		FTM_FILTER,
+		FTM_REFRESH,
+		FTM_SORT,
+		FTM_PICK,
+		FTM_STATEMACHINE,
+		
+		// Temp
+		FTM_TEMP1,
+		FTM_TEMP2,
+		FTM_TEMP3,
+		FTM_TEMP4,
+		FTM_TEMP5,
+		FTM_TEMP6,
+		FTM_TEMP7,
+		FTM_TEMP8,
+		FTM_TEMP9,
+		FTM_TEMP10,
+		FTM_TEMP11,
+		FTM_TEMP12,
+		FTM_TEMP13,
+		FTM_TEMP14,
+		FTM_TEMP15,
+		
+		FTM_OTHER, // Special, used by display code
+		
+		FTM_NUM_TYPES
+	};
+	enum { FTM_HISTORY_NUM = 60 };
+	enum { FTM_MAX_DEPTH = 64 };
+	
+public:
+	static EFastTimerType sCurType;
+
+	LLFastTimer(EFastTimerType type)
+	{
+#if FAST_TIMER_ON
+		mType = type;
+		sCurType = type;
+		// These don't get counted, because they use CPU clockticks
+		//gTimerBins[gCurTimerBin]++;
+		//LLTimer::sNumTimerCalls++;
+
+		U64 cpu_clocks =  getCPUClockCount32();
+
+		sStart[sCurDepth] = cpu_clocks;
+		sCurDepth++;
+#endif
+	};
+	~LLFastTimer()
+	{
+#if FAST_TIMER_ON
+		U64 end,delta;
+		int i;
+
+		// These don't get counted, because they use CPU clockticks
+		//gTimerBins[gCurTimerBin]++;
+		//LLTimer::sNumTimerCalls++;
+		end =  getCPUClockCount32();
+
+		sCurDepth--;
+		delta = end - sStart[sCurDepth];
+		sCounter[mType] += delta;
+		sCalls[mType]++;
+		// Subtract delta from parents
+		for (i=0; i<sCurDepth; i++)
+			sStart[i] += delta;
+#endif
+	}
+
+	static void reset();
+	static U64 countsPerSecond();
+
+public:
+	static int sCurDepth;
+	static U64 sStart[FTM_MAX_DEPTH];
+	static U64 sCounter[FTM_NUM_TYPES];
+	static U64 sCalls[FTM_NUM_TYPES];
+	static U64 sCountAverage[FTM_NUM_TYPES];
+	static U64 sCallAverage[FTM_NUM_TYPES];
+	static U64 sCountHistory[FTM_HISTORY_NUM][FTM_NUM_TYPES];
+	static U64 sCallHistory[FTM_HISTORY_NUM][FTM_NUM_TYPES];
+
+	static int sPauseHistory;
+	static int sResetHistory;
+	
+	static U32 getCPUClockCount32();
+	static U64 getCPUClockCount64();
+
+	static U64 sClockResolution;
+	static S32 sCurFrameIndex;
+	static S32 sLastFrameIndex;
+	
+	EFastTimerType mType;
+};
 
-// pull in the actual class definition
-#include "llfasttimer_class.h"
 
 #endif // LL_LLFASTTIMER_H