script.cpp

// Copyright (C) Calum Grant 2008

#include "cppscript"
#include <sstream>

not_supported::not_supported(const var & v, std::string const & op) : 
        exception("not_supported", "Operation '" + op + "' not supported on " + v.as_string())
{
}


not_supported::~not_supported() throw ()
{
}


static std::string build_error(var_impl * v, std::string const & op)
{
        std::ostringstream ss;
        ss << "Operation '" << op << "' not supported on ";
        v->output(ss);
        return ss.str();
}


not_supported::not_supported(var_impl * v, std::string const & op) : 
        exception("not_supported", build_error(v,op) )
{
}


not_found::not_found(var const & e) :
        exception("not_found", "No such member: " + e.as_string(), e)
{
}


not_found::~not_found() throw()
{ 
}


exception::exception() : 
        std::runtime_error("exception"),
        var( object("exception").extend("text", "exception")("data", var())("stack", stack_trace()) )
{
}


exception::exception(const char * class_name) : 
        std::runtime_error(class_name),
        var( object(class_name).extend("text", class_name)("data", var())("stack", stack_trace()) )
{
}


exception::exception(const char * class_name, const var & message) : 
        std::runtime_error(message.as_string().c_str()),
        var( object(class_name).extend("text", message)("data", var())("stack", stack_trace()) )
{
}


exception::exception(const char * class_name, const var & message, const var & data) : 
        std::runtime_error(message.as_string().c_str()),
        var( object(class_name).extend("text", message)("data", data)("stack", stack_trace()) )
{
}


dynamic::exception::~exception() throw() 
{ 
}


namespace
{
        std::string build_args_string(int expected, int actual)
        {
                std::ostringstream ss;
                ss << "Wrong number of arguments: expected " << expected << " arguments but received " << actual << " arguments";
                return ss.str();
        }
}


wrong_number_of_args::wrong_number_of_args(int e, int a) : 
        exception("wrong_number_of_args", build_args_string(e,a))
{
}


wrong_number_of_args::~wrong_number_of_args() throw() 
{ 
}


invalid_string::invalid_string() : exception("invalid_string", "Invalid string")
{
}


invalid_string::~invalid_string() throw()
{
}


too_many_arguments::too_many_arguments() : exception("too_many_arguments", "Too many arguments")
{
}


too_many_arguments::~too_many_arguments() throw()
{
}


expired_iterator::expired_iterator() : exception("expired_iterator", "Expired iterator")
{
}


expired_iterator::~expired_iterator() throw()
{
}


std::ostream & dynamic::operator<<(std::ostream & os, var const & a)
{
        a.impl().output(os);
        return os;
}


std::basic_ostream<wchar_t> & dynamic::operator<<(std::basic_ostream<wchar_t> & os, var const & a)
{
        a.impl().output(os);
        return os;
}


var dynamic::global()
{
        static var global_var(global(object));
        return global_var;
}


var dynamic::exception_description(const var & ex)
{
        // Handle other types of exception as well.
        if( !ex.contains("text") || !ex.contains("stack") )
                return ex;

        std::ostringstream ss;

        ss << var(ex["text"]) << " (" << ex.class_name() << ")";

        bool first=false;

        foreach( i, ex["stack"] )
        {
                if(first)
                {
                        first=false;
                        ss << "\n    in function " << i;
                }
                else
                        ss << "\n    called from " << i;
        }

        return ss.str();
}


var dynamic::version()
{
        return "0.9.4";  
}

---