1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// -*- 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;
}
/** Build an argument list suitable for calling a \c btp_func,
\c bool_func, and so on. Since this takes an rvalue_list and
not an rvalue, it is a function rather than a class
member.
This function performs a common task but does not fit within the RValue
class well. It is used by Clause and ce_expr.y.
@param args A list of RValue objects
@param dds Use this DDS when evaluating functions */
BaseType **
build_btp_args(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];
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.");
}
#if 0
argv[index] = 0; // Add the null terminator.
#endif
return argv;
}
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();
}
/** Return the BaseType * for a given rvalue. If
the rvalue is a func_rvalue, evaluates the func_rvalue and returns the
result. The functions referenced by func_rvalues must encapsulate their
return values in BaseType *s.
@param dds The dds to pass to a function.
*/
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
|
