RValue.cc

 
// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
// (c) COPYRIGHT URI/MIT 1996-1999
// Please read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>
 
// This file contains mfuncs defined for struct rvalue (see expr.h) that
// *cannot* be included in that struct's declaration because their
// definitions must follow *both* rvalue's and func_rvalue's declarations.
// jhrg 3/4/96
 
#include "config.h"
 
#include <cassert>
#include <iostream>
 
#include "BaseType.h"
#include "expr.h"
#include "RValue.h"
#include "DDS.h"
#include "dods-limits.h"
#include "util.h"
 
using namespace std;
 
namespace libdap {
 
rvalue_list *
make_rvalue_list(rvalue *rv)
{
    assert(rv);
 
    rvalue_list *rvals = new rvalue_list;
 
    return append_rvalue_list(rvals, rv);
}
 
// Given a rvalue_list pointer RVALS and a value pointer VAL, make a variable
// to hold VAL and append that variable to the list RVALS.
//
// Returns: A pointer to the updated rvalue_list.
 
rvalue_list *
append_rvalue_list(rvalue_list *rvals, rvalue *rv)
{
    rvals->push_back(rv);
 
    return rvals;
}
 
 
BaseType **
build_btp_args(const rvalue_list *args, DDS &dds)
{
    int argc = 0;
 
    if (args)
        argc = args->size();
 
    // Sanitize allocation size
    if (!size_ok(sizeof(BaseType*), argc + 1))
        throw Error(malformed_expr, string("Malformed argument list (")
        + long_to_string(argc) + string(")."));
 
    // Add space for a null terminator
    BaseType **argv = new BaseType*[argc + 1];
    argv[argc] = nullptr;
 
    if (argc) {
        int i = 0;
        for (auto btp: *args) {
            argv[i++] = btp->bvalue(dds);
        }
 
        assert(i == argc);
    }
 
    return argv;
}
 
#if 0
    int index = 0;
    if (argv && argc) {
        for (rvalue::Args_iter i = args->begin(); i != args->end() && index < argc + 1; ++i)
            argv[index++] = (*i)->bvalue(dds);
 
        argv[index] = 0; // Add the null terminator.
    }
 
    if (index != argc) {
        delete[] argv;
        throw InternalErr(__FILE__, __LINE__, "index out of range.");
    }
 
    return argv;
#endif
 
rvalue::rvalue(BaseType *bt): d_value(bt), d_func(0), d_args(0)
{}
 
rvalue::rvalue(btp_func f, vector<rvalue *> *a) : d_value(0), d_func(f), d_args(a)
{}
 
rvalue::rvalue(): d_value(0), d_func(0), d_args(0)
{}
 
rvalue::~rvalue()
{
    // Deleting the BaseType pointers in value and args is a bad idea since
    // those might be variables in the dataset. The DDS dtor will take care
    // of deleting them. The constants wrapped in BaseType objects should be
    // pushed on the list of CE-allocated temp objects which the CE frees.
 
    // ADB: the d_args vector still needs to be deleted
    if (d_args != 0) {
        for (std::vector<rvalue *>::iterator iter = d_args->begin(); iter != d_args->end(); ++iter) {
            delete *iter;
        }
        delete d_args;
    }
}
 
string
rvalue::value_name()
{
    assert(d_value);
 
    return d_value->name();
}
 
BaseType *
rvalue::bvalue(DDS &dds)
{
    if (d_value) {        // i.e., if this RValue is a BaseType
        return d_value;
    }
    else if (d_func) {
        // If func is true, then args must be set. See the constructor.
        // 12/23/04 jhrg
        BaseType **argv = build_btp_args(d_args, dds);
        BaseType *ret_val;
        (*d_func)(d_args->size(), argv, dds, &ret_val);
        delete[] argv;
        return ret_val;
    }
    else {
        return 0;
    }
}
 
} // namespace libdap