1 files changed, 543 insertions, 0 deletions

diff --git a/linden/indra/newview/llcommandlineparser.cpp b/linden/indra/newview/llcommandlineparser.cpp
new file mode 100644
index 0000000..8123632
--- /dev/null
+++ b/linden/indra/newview/llcommandlineparser.cpp
@@ -0,0 +1,543 @@
+/**
+ * @file llcommandlineparser.cpp
+ * @brief The LLCommandLineParser class definitions
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2008, 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 "llviewerprecompiledheaders.h"
+#include "llcommandlineparser.h"
+
+// *NOTE: The boost::lexical_cast generates 
+// the warning C4701(local used with out assignment) in VC7.1.
+// Disable the warning for the boost includes.
+#if _MSC_VER
+#   pragma warning(push)
+#   pragma warning( disable : 4701 )
+#else
+// NOTE: For the other platforms?
+#endif
+
+#include <boost/program_options.hpp>
+#include <boost/bind.hpp>
+#include<boost/tokenizer.hpp>
+
+#if _MSC_VER
+#   pragma warning(pop)
+#endif
+
+#include "llsdserialize.h"
+#include <iostream>
+#include <sstream>
+
+#include "llcontrol.h"
+
+namespace po = boost::program_options;
+
+// *NTOE:MEP - Currently the boost object reside in file scope. 
+// This has a couple of negatives, they are always around and 
+// there can be only one instance of each. 
+// The plus is that the boost-ly-ness of this implementation is 
+// hidden from the rest of the world. 
+// Its importatnt to realize that multiple LLCommandLineParser objects 
+// will all have this single repository of option escs and parsed options.
+// This could be good or bad, and probably won't matter for most use cases.
+namespace 
+{
+    po::options_description gOptionsDesc;
+    po::positional_options_description gPositionalOptions;
+        po::variables_map gVariableMap;
+    
+    const LLCommandLineParser::token_vector_t gEmptyValue;
+
+    void read_file_into_string(std::string& str, const std::basic_istream < char >& file)
+    {
+            std::ostringstream oss;
+            oss << file.rdbuf();
+            str = oss.str();
+    }
+
+    bool gPastLastOption = false;
+}
+
+class LLCLPError : public std::logic_error {
+public:
+    LLCLPError(const std::string& what) : std::logic_error(what) {}
+};
+
+class LLCLPLastOption : public std::logic_error {
+public:
+    LLCLPLastOption(const std::string& what) : std::logic_error(what) {}
+};
+
+class LLCLPValue : public po::value_semantic_codecvt_helper<char> 
+{
+    unsigned mMinTokens;
+    unsigned mMaxTokens;
+    bool mIsComposing;
+    typedef boost::function1<void, const LLCommandLineParser::token_vector_t&> notify_callback_t;
+    notify_callback_t mNotifyCallback;
+    bool mLastOption;
+
+public:
+    LLCLPValue() :
+        mMinTokens(0),
+        mMaxTokens(0),
+        mIsComposing(false),
+        mLastOption(false)
+        {}
+      
+    virtual ~LLCLPValue() {};
+
+    void setMinTokens(unsigned c) 
+    {
+        mMinTokens = c;
+    }
+
+    void setMaxTokens(unsigned c) 
+    {
+        mMaxTokens = c;
+    }
+
+    void setComposing(bool c)
+    {
+        mIsComposing = c;
+    }
+
+    void setLastOption(bool c)
+    {
+        mLastOption = c;
+    }
+
+    void setNotifyCallback(notify_callback_t f)
+    {
+        mNotifyCallback = f;
+    }
+
+    // Overrides to support the value_semantic interface.
+    virtual std::string name() const 
+    { 
+        const std::string arg("arg");
+        const std::string args("args");
+        return (max_tokens() > 1) ? args : arg; 
+    }
+
+    virtual unsigned min_tokens() const
+    {
+        return mMinTokens;
+    }
+
+    virtual unsigned max_tokens() const 
+    {
+        return mMaxTokens;
+    }
+
+    virtual bool is_composing() const 
+    {
+        return mIsComposing;
+    }
+
+    virtual bool apply_default(boost::any& value_store) const
+    {
+        return false; // No defaults.
+    }
+
+    virtual void notify(const boost::any& value_store) const
+    {
+        const LLCommandLineParser::token_vector_t* value =
+            boost::any_cast<const LLCommandLineParser::token_vector_t>(&value_store);
+        if(mNotifyCallback) 
+        {
+           mNotifyCallback(*value);
+        }
+
+    }
+
+protected:
+    void xparse(boost::any& value_store,
+         const std::vector<std::string>& new_tokens) const
+    {
+        if(gPastLastOption)
+        {
+            throw(LLCLPLastOption("Don't parse no more!"));
+        }
+
+        // Error checks. Needed?
+        if (!value_store.empty() && !is_composing()) 
+        {
+            throw(LLCLPError("Non composing value with multiple occurences."));
+        }
+        if (new_tokens.size() < min_tokens() || new_tokens.size() > max_tokens())
+        {
+            throw(LLCLPError("Illegal number of tokens specified."));
+        }
+        
+        if(value_store.empty())
+        {
+            value_store = boost::any(LLCommandLineParser::token_vector_t());
+        }
+        LLCommandLineParser::token_vector_t* tv = 
+            boost::any_cast<LLCommandLineParser::token_vector_t>(&value_store); 
+       
+        for(unsigned i = 0; i < new_tokens.size() && i < mMaxTokens; ++i)
+        {
+            tv->push_back(new_tokens[i]);
+        }
+
+        if(mLastOption)
+        {
+            gPastLastOption = true;
+        }
+    }
+};
+
+//----------------------------------------------------------------------------
+// LLCommandLineParser defintions
+//----------------------------------------------------------------------------
+void LLCommandLineParser::addOptionDesc(const LLString& option_name, 
+                                        boost::function1<void, const token_vector_t&> notify_callback,
+                                        unsigned int token_count,
+                                        const LLString& description,
+                                        const LLString& short_name,
+                                        bool composing,
+                                        bool positional,
+                                        bool last_option)
+{
+    // Compose the name for boost::po. 
+    // It takes the format "long_name, short name"
+    const LLString comma(",");
+    LLString boost_option_name = option_name;
+    if(short_name != LLString::null)
+    {
+        boost_option_name += comma;
+        boost_option_name += short_name;
+    }
+   
+    LLCLPValue* value_desc = new LLCLPValue();
+    value_desc->setMinTokens(token_count);
+    value_desc->setMaxTokens(token_count);
+    value_desc->setComposing(composing);
+    value_desc->setLastOption(last_option);
+
+    boost::shared_ptr<po::option_description> d(
+            new po::option_description(boost_option_name.c_str(), 
+                                    value_desc, 
+                                    description.c_str()));
+
+    if(!notify_callback.empty())
+    {
+        value_desc->setNotifyCallback(notify_callback);
+    }
+
+    gOptionsDesc.add(d);
+
+    if(positional)
+    {
+        gPositionalOptions.add(boost_option_name.c_str(), token_count);
+    }
+}
+
+bool LLCommandLineParser::parseAndStoreResults(po::command_line_parser& clp)
+{
+    try
+    {
+        clp.options(gOptionsDesc);
+        clp.positional(gPositionalOptions);
+        clp.style(po::command_line_style::default_style 
+                  | po::command_line_style::allow_long_disguise);
+                if(mExtraParser)
+                {
+                        clp.extra_parser(mExtraParser);
+                }
+                        
+        po::basic_parsed_options<char> opts = clp.run();
+        po::store(opts, gVariableMap);
+    }
+    catch(po::error& e)
+    {
+        llwarns << "Caught Error:" << e.what() << llendl;
+                mErrorMsg = e.what();
+        return false;
+    }
+    catch(LLCLPError& e)
+    {
+        llwarns << "Caught Error:" << e.what() << llendl;
+                mErrorMsg = e.what();
+        return false;
+    }
+    catch(LLCLPLastOption&) 
+    {
+        // Continue without parsing.
+                std::string msg = "Found tokens past last option. Ignoring.";
+        llwarns << msg << llendl;
+                mErrorMsg = msg;
+        // boost::po will have stored a mal-formed option. 
+        // All such options will be removed below.
+        for(po::variables_map::iterator i = gVariableMap.begin(); i != gVariableMap.end();)
+        {
+            po::variables_map::iterator tempI = i++;
+            if(tempI->second.empty())
+            {
+                gVariableMap.erase(tempI);
+            }
+        }
+    } 
+    return true;
+}
+
+bool LLCommandLineParser::parseCommandLine(int argc, char **argv)
+{
+    po::command_line_parser clp(argc, argv);
+    return parseAndStoreResults(clp);
+}
+
+bool LLCommandLineParser::parseCommandLineString(const std::string& str)
+{
+    // Split the string content into tokens
+    boost::escaped_list_separator<char> sep("\\", "\r\n ", "\"'");
+    boost::tokenizer< boost::escaped_list_separator<char> > tok(str, sep);
+    std::vector<std::string> tokens;
+    // std::copy(tok.begin(), tok.end(), std::back_inserter(tokens));
+    for(boost::tokenizer< boost::escaped_list_separator<char> >::iterator i = tok.begin();
+        i != tok.end();
+        ++i)
+    {
+        if(0 != i->size())
+        {
+            tokens.push_back(*i);
+        }
+    }
+
+    po::command_line_parser clp(tokens);
+    return parseAndStoreResults(clp);
+        
+}
+
+bool LLCommandLineParser::parseCommandLineFile(const std::basic_istream < char >& file)
+{
+    std::string args;
+    read_file_into_string(args, file);
+
+    return parseCommandLineString(args);
+}
+
+void LLCommandLineParser::notify()
+{
+    po::notify(gVariableMap);    
+}
+
+void LLCommandLineParser::printOptions() const
+{
+    for(po::variables_map::iterator i = gVariableMap.begin(); i != gVariableMap.end(); ++i)
+    {
+        std::string name = i->first;
+        token_vector_t values = i->second.as<token_vector_t>();
+        std::ostringstream oss;
+        oss << name << ": ";
+        for(token_vector_t::iterator t_itr = values.begin(); t_itr != values.end(); ++t_itr)
+        {
+            oss << t_itr->c_str() << " ";
+        }
+        llinfos << oss.str() << llendl;
+    }
+}
+
+std::ostream& LLCommandLineParser::printOptionsDesc(std::ostream& os) const
+{
+    return os << gOptionsDesc;
+}
+
+bool LLCommandLineParser::hasOption(const std::string& name) const
+{
+    return gVariableMap.count(name) > 0;
+}
+
+const LLCommandLineParser::token_vector_t& LLCommandLineParser::getOption(const std::string& name) const
+{
+    if(hasOption(name))
+    {
+        return gVariableMap[name].as<token_vector_t>();
+    }
+
+    return gEmptyValue;
+}
+
+//----------------------------------------------------------------------------
+// LLControlGroupCLP defintions
+//----------------------------------------------------------------------------
+void setControlValueCB(const LLCommandLineParser::token_vector_t& value, 
+                       const LLString& opt_name, 
+                       LLControlGroup* ctrlGroup)
+{
+    if(value.size() > 1)
+    {
+        llwarns << "Ignoring extra tokens mapped to the setting: " << opt_name << "." << llendl; 
+    }
+    
+    // *FIX: Do sematic conversion here.
+    // LLSD (ImplString) Is no good for doing string to type conversion for...
+    // booleans
+    // compound types
+    // ?...
+
+    LLControlVariable* ctrl = ctrlGroup->getControl(opt_name);
+    if(NULL != ctrl)
+    {
+        switch(ctrl->type())
+        {
+        case TYPE_BOOLEAN:
+            if(value.size() > 1)
+            {
+                llwarns << "Ignoring extra tokens." << llendl; 
+            }
+              
+            if(value.size() > 0)
+            {
+                // There's a token. check the string for true/false/1/0 etc.
+                BOOL result = false;
+                BOOL gotSet = LLString::convertToBOOL(value[0], result);
+                if(gotSet)
+                {
+                    ctrl->setValue(LLSD(result), false);
+                }
+            }
+            else
+            {
+                ctrl->setValue(LLSD(true), false);
+            }
+            break;
+
+        default:
+            {
+                // For the default types, let llsd do the conversion.
+                if(value.size() > 1)
+                {
+                    // Assume its an array...
+                    LLSD llsdArray;
+                    for(unsigned int i = 0; i < value.size(); ++i)
+                    {
+                        LLSD llsdValue;
+                        llsdValue.assign(LLSD::String(value[i]));
+                        llsdArray.set(i, llsdValue);
+                    }
+
+                    ctrl->setValue(llsdArray, false);
+                }
+                else if(value.size() > 0)
+                {
+                    LLSD llsdValue;
+                    llsdValue.assign(LLSD::String(value[0]));
+                    ctrl->setValue(llsdValue, false);
+                }
+            }
+            break;
+        }
+    }
+    else
+    {
+        llwarns << "Command Line option mapping '" 
+            << opt_name 
+            << "' not found! Ignoring." 
+            << llendl;
+    }
+}
+
+void LLControlGroupCLP::configure(const LLString& config_filename, LLControlGroup* controlGroup)
+{
+    // This method reads the llsd based config file, and uses it to set 
+    // members of a control group.
+    LLSD clpConfigLLSD;
+    
+    llifstream input_stream;
+    input_stream.open(config_filename.c_str(), std::ios::in | std::ios::binary);
+
+    if(input_stream.is_open())
+    {
+        LLSDSerialize::fromXML(clpConfigLLSD, input_stream);
+        for(LLSD::map_iterator option_itr = clpConfigLLSD.beginMap(); 
+            option_itr != clpConfigLLSD.endMap(); 
+            ++option_itr)
+        {
+            LLSD::String long_name = option_itr->first;
+            LLSD option_params = option_itr->second;
+            
+            LLString desc("n/a");
+            if(option_params.has("desc"))
+            {
+                desc = option_params["desc"].asString();
+            }
+            
+            LLString short_name = LLString::null;
+            if(option_params.has("short"))
+            {
+                short_name = option_params["short"].asString();
+            }
+
+            unsigned int token_count = 0;
+            if(option_params.has("count"))
+            {
+                token_count = option_params["count"].asInteger();
+            }
+
+            bool composing = false;
+            if(option_params.has("compose"))
+            {
+                composing = option_params["compose"].asBoolean();
+            }
+
+            bool positional = false;
+            if(option_params.has("positional"))
+            {
+                positional = option_params["positional"].asBoolean();
+            }
+
+            bool last_option = false;
+            if(option_params.has("last_option"))
+            {
+                last_option = option_params["last_option"].asBoolean();
+            }
+
+            boost::function1<void, const token_vector_t&> callback;
+            if(option_params.has("map-to") && (NULL != controlGroup))
+            {
+                LLString controlName = option_params["map-to"].asString();
+                callback = boost::bind(setControlValueCB, _1, 
+                                       controlName, controlGroup);
+            }
+
+            this->addOptionDesc(
+                long_name, 
+                callback,
+                token_count, 
+                desc, 
+                short_name, 
+                composing,
+                positional,
+                last_option);
+        }
+    }
+}