45 #ifndef TM_IN_SYS_TIME
59 #include <sys/types.h>
96 #ifdef COMPUTE_ENDIAN_AT_RUNTIME
99 char *c =
reinterpret_cast<char*
>(&i);
104 #ifdef WORDS_BIGENDIAN
128 "The CE Evaluator built an argument list where some constants held no values.");
130 return static_cast<Str*
>(arg)->value();
133 template<
class T>
static void set_array_using_double_helper(Array *a,
double *src,
int src_len)
139 vector<T> values(src_len);
140 for (
int i = 0; i < src_len; ++i)
141 values[i] = (T) src[i];
144 a->set_value(values, src_len);
178 "The function requires a numeric-type array argument.");
184 if (dest->
length() != src_len)
186 "The source and destination array sizes don't match ("
196 set_array_using_double_helper<dods_byte>(dest, src, src_len);
199 set_array_using_double_helper<dods_uint16>(dest, src, src_len);
202 set_array_using_double_helper<dods_int16>(dest, src, src_len);
205 set_array_using_double_helper<dods_uint32>(dest, src, src_len);
208 set_array_using_double_helper<dods_int32>(dest, src, src_len);
211 set_array_using_double_helper<dods_float32>(dest, src, src_len);
214 set_array_using_double_helper<dods_float64>(dest, src, src_len);
219 set_array_using_double_helper<dods_byte>(dest, src, src_len);
222 set_array_using_double_helper<dods_int8>(dest, src, src_len);
225 set_array_using_double_helper<dods_uint64>(dest, src, src_len);
228 set_array_using_double_helper<dods_int64>(dest, src, src_len);
232 "The argument list built by the CE parser contained an unsupported numeric type.");
239 template<
class T>
static double *extract_double_array_helper(Array * a)
243 int length = a->length();
248 double *dest =
new double[length];
249 for (
int i = 0; i < length; ++i)
250 dest[i] = (
double) b[i];
273 "The function requires a DAP numeric-type array argument.");
277 string(
"The Array '") + a->
name() +
278 "'does not contain values.");
286 return extract_double_array_helper<dods_byte>(a);
288 return extract_double_array_helper<dods_uint16>(a);
290 return extract_double_array_helper<dods_int16>(a);
292 return extract_double_array_helper<dods_uint32>(a);
294 return extract_double_array_helper<dods_int32>(a);
296 return extract_double_array_helper<dods_float32>(a);
302 return extract_double_array_helper<dods_float64>(a);
306 return extract_double_array_helper<dods_byte>(a);
308 return extract_double_array_helper<dods_int8>(a);
310 return extract_double_array_helper<dods_uint64>(a);
312 return extract_double_array_helper<dods_int64>(a);
315 "The argument list built by the CE parser contained an unsupported numeric type.");
322 template<
class T>
static void extract_double_array_helper(Array * a, vector<double> &dest)
325 assert(dest.size() == (
unsigned long)a->length());
327 int length = a->length();
332 for (
int i = 0; i < length; ++i)
333 dest[i] = (
double) b[i];
355 "The function requires a DAP numeric-type array argument.");
359 string(
"The Array '") + a->
name() +
360 "'does not contain values.");
370 return extract_double_array_helper<dods_byte>(a, dest);
372 return extract_double_array_helper<dods_uint16>(a, dest);
374 return extract_double_array_helper<dods_int16>(a, dest);
376 return extract_double_array_helper<dods_uint32>(a, dest);
378 return extract_double_array_helper<dods_int32>(a, dest);
380 return extract_double_array_helper<dods_float32>(a, dest);
382 return a->value(&dest[0]);
387 return extract_double_array_helper<dods_byte>(a, dest);
389 return extract_double_array_helper<dods_int8>(a, dest);
391 return extract_double_array_helper<dods_uint64>(a, dest);
393 return extract_double_array_helper<dods_int64>(a, dest);
396 "The argument list built by the CE parser contained an unsupported numeric type.");
416 "The function requires a numeric-type argument.");
420 "The Evaluator built an argument list where some constants held no values.");
426 switch (arg->
type()) {
428 return (
double)(
static_cast<Byte*
>(arg)->value());
430 return (
double)(
static_cast<UInt16*
>(arg)->value());
432 return (
double)(
static_cast<Int16*
>(arg)->value());
434 return (
double)(
static_cast<UInt32*
>(arg)->value());
436 return (
double)(
static_cast<Int32*
>(arg)->value());
438 return (
double)(
static_cast<Float32*
>(arg)->value());
440 return static_cast<Float64*
>(arg)->value();
444 return (
double)(
static_cast<Byte*
>(arg)->value());
446 return (
double)(
static_cast<Int8*
>(arg)->value());
448 return (
double)(
static_cast<UInt64*
>(arg)->value());
450 return (
double)(
static_cast<Int64*
>(arg)->value());
454 "The argument list built by the parser contained an unsupported numeric type.");
471 if (name.find_first_of(
' ') == name.npos)
475 unsigned int i = name.find_first_not_of(
' ');
476 string tmp_name = name.substr(i);
479 unsigned int j = tmp_name.find(
'?') + 1;
480 i = tmp_name.find_first_not_of(
' ', j);
481 tmp_name.erase(j, i - j);
495 vector<string> names(l.size());
498 typedef std::vector<BaseType *>::const_iterator citer ;
499 for (citer i = l.begin(); i != l.end(); i++) {
501 names[nelem++] = (*i)->name();
502 DBG(cerr <<
"NAMES[" << nelem - 1 <<
"]=" << names[nelem-1] << endl);
506 sort(names.begin(), names.end());
509 sort(names.begin(), names.end());
512 for (
int j = 1; j < nelem; ++j) {
513 if (names[j-1] == names[j]) {
515 oss <<
"The variable `" << names[j]
516 <<
"' is used more than once in " << type_name <<
" `"
537 extern "C" const char *
543 extern "C" const char *
559 if (time(&TimBin) == (time_t) - 1)
560 return string(
"time() error");
562 char *ctime_value = ctime(&TimBin);
564 string TimStr = ctime_value;
565 return TimStr.substr(0, TimStr.size() - 2);
579 for (
unsigned int i = 0; i < s.length(); i++)
580 s[i] = tolower(s[i]);
591 return (!s.empty() && s[0] ==
'\"' && s[s.length()-1] ==
'\"');
604 return s.substr(1, s.length() - 2);
612 if (strcmp(name,
"Byte") == 0)
615 if (strcmp(name,
"Char") == 0)
618 if (strcmp(name,
"Int8") == 0)
621 if (strcmp(name,
"UInt8") == 0)
624 if (strcmp(name,
"Int16") == 0)
627 if (strcmp(name,
"UInt16") == 0)
630 if (strcmp(name,
"Int32") == 0)
633 if (strcmp(name,
"UInt32") == 0)
636 if (strcmp(name,
"Int64") == 0)
639 if (strcmp(name,
"UInt64") == 0)
642 if (strcmp(name,
"Float32") == 0)
645 if (strcmp(name,
"Float64") == 0)
648 if (strcmp(name,
"String") == 0)
654 if (strcmp(name,
"Url") == 0 || strcmp(name,
"URL") == 0)
657 if (strcmp(name,
"Enum") == 0)
660 if (strcmp(name,
"Opaque") == 0)
663 if (strcmp(name,
"Array") == 0)
666 if (strcmp(name,
"Structure") == 0)
669 if (strcmp(name,
"Sequence") == 0)
672 if (strcmp(name,
"Grid") == 0)
690 return string(
"Null");
692 return string(
"Byte");
694 return string(
"Int16");
696 return string(
"UInt16");
698 return string(
"Int32");
700 return string(
"UInt32");
702 return string(
"Float32");
704 return string(
"Float64");
706 return string(
"String");
708 return string(
"Url");
711 return string(
"Array");
713 return string(
"Structure");
715 return string(
"Sequence");
717 return string(
"Grid");
720 throw InternalErr(__FILE__, __LINE__,
"Unknown type.");
736 return string(
"Null");
738 return string(
"Byte");
740 return string(
"Char");
742 return string(
"Int8");
744 return string(
"UInt8");
746 return string(
"Int16");
748 return string(
"UInt16");
750 return string(
"Int32");
752 return string(
"UInt32");
754 return string(
"Int64");
756 return string(
"UInt64");
758 return string(
"Enum");
761 return string(
"Float32");
763 return string(
"Float64");
766 return string(
"String");
768 return string(
"URL");
771 return string(
"Opaque");
774 return string(
"Array");
777 return string(
"Structure");
779 return string(
"Sequence");
781 return string(
"Group");
784 throw InternalErr(__FILE__, __LINE__,
"Unknown type.");
978 return (stat(dir.c_str(), &buf) == 0) && (buf.st_mode & S_IFDIR);
988 char digits[] =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
992 if (base > 36 || base < 2) {
994 std::invalid_argument ex(
"The parameter base has an invalid value.");
999 r = ldiv(labs(val), base);
1007 str_val += digits[(int)r.rem];
1045 static const char path_sep[] =
1049 static const char path_sep[] =
1065 string::size_type pos = path.rfind(path_sep);
1067 return (pos == string::npos) ? path : path.substr(++pos);
1070 #define CHECK_BIT( tab, bit ) ( tab[ (bit)/8 ] & (1<<( (bit)%8 )) )
1071 #define BITLISTSIZE 16
1077 static void globchars(
const char *s,
const char *e,
char *b) {
1088 if (s + 2 < e && s[1] ==
'-') {
1089 for (c = s[0]; c <= s[2]; c++)
1090 b[c / 8] |= (1 << (c % 8));
1095 b[c / 8] |= (1 << (c % 8));
1148 const char *here = c;
1152 }
while (here == c || *c !=
']');
1157 globchars(here, c, bitlist);
1159 if (!
CHECK_BIT( bitlist, *(
unsigned char *)s ))
1166 const char *here = s;
1179 r = *c ?
glob(c, s) : *s ? -1 : 0;
1194 if (!*c || *s++ != *c++)
1219 return (sz > 0 && nelem < UINT_MAX / sz);
1241 if (path.length() > 255)
1244 Regex name(
"[-0-9A-z_./]+");
1246 name =
"[:print:]+";
1248 string::size_type len = path.length();
1249 int result = name.match(path.c_str(), len);
1252 if (len > INT_MAX || result != static_cast<int>(len))
1267 return (
string)
"OPeNDAP DAP/" +
libdap_version() +
": compiled on " + __DATE__ +
":" + __TIME__ ;
Holds an 8-bit signed integer value.
Holds a64-bit signed integer.
virtual bool read_p()
Has this variable been read?
Type get_type(const char *name)
bool is_constructor_type(Type t)
Returns true if the instance is a constructor (i.e., Structure, Sequence or Grid) type variable...
string prune_spaces(const string &name)
virtual int length() const
Holds an unsigned 16-bit integer.
virtual void set_read_p(bool state)
Indicates that the data is ready to send.
string extract_string_argument(BaseType *arg)
bool dir_exists(const string &dir)
bool size_ok(unsigned int sz, unsigned int nelem)
sanitize the size of an array. Test for integer overflow when dynamically allocating an array...
bool is_vector_type(Type t)
Returns true if the instance is a vector (i.e., array) type variable.
Type
Identifies the data type.
Type type() const
Returns the type of the class instance.
Holds a 32-bit floating point value.
A class for software fault reporting.
virtual BaseType * var(const string &name="", bool exact_match=true, btp_stack *s=0)
Holds character string data.
void set_array_using_double(Array *dest, double *src, int src_len)
bool pathname_ok(const string &path, bool strict)
Does the string name a potentially valid pathname? Test the given pathname to verify that it is a val...
Holds a 16-bit signed integer value.
string D4type_name(Type t)
Returns the type of the class instance as a string. Supports all DAP4 types and not the DAP2-only typ...
string path_to_filename(string path)
bool is_quoted(const string &s)
bool is_simple_type(Type t)
Returns true if the instance is a numeric, string or URL type variable.
const char * libdap_root()
Holds a 64-bit unsigned integer.
void append_long_to_string(long val, int base, string &str_val)
double extract_double_value(BaseType *arg)
string name() const
Returns the name of the class instance.
void extract_double_array(Array *a, vector< double > &dest)
string long_to_string(long val, int base)
#define CHECK_BIT(tab, bit)
string double_to_string(const double &num)
virtual bool is_simple_type() const
Returns true if the instance is a numeric, string or URL type variable.
string remove_quotes(const string &s)
The basic data type for the DODS DAP types.
string D2type_name(Type t)
Returns the type of the class instance as a string. Supports all DAP2 types and not the DAP4-only typ...
Holds a 64-bit (double precision) floating point value.
bool unique_names(vector< BaseType * > l, const string &var_name, const string &type_name, string &msg)
A class for error processing.
bool is_host_big_endian()
Does this host use big-endian byte order?
Holds a 32-bit unsigned integer.
const char * libdap_version()
A multidimensional array of identical data types.
int glob(const char *c, const char *s)
bool is_integer_type(Type t)
Holds a 32-bit signed integer.
void append_double_to_string(const double &num, string &str)
const char * libdap_name()