// -*- 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 1994-1999

// Please read the full copyright statement in the file COPYRIGHT_URI.

//

// Authors:

//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>

// Utility functions used by the api.

//

// jhrg 9/21/94

#include "config.h"

#include <fstream>

#include <cassert>

#include <cstring>

#include <climits>

#include <cstdlib>

#include <ctype.h>

#ifndef TM_IN_SYS_TIME

#include <time.h>

#else

#include <sys/time.h>

#endif

#ifndef WIN32

#include <unistd.h>    // for stat

#else

#include <io.h>

#include <fcntl.h>

#include <process.h>

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include <string>

#include <sstream>

#include <vector>

#include <algorithm>

#include <stdexcept>

#include "BaseType.h"

#include "Byte.h"

#include "Int16.h"

#include "Int32.h"

#include "UInt16.h"

#include "UInt32.h"

#include "Float32.h"

#include "Float64.h"

#include "Str.h"

#include "Array.h"

#include "Int64.h"

#include "UInt64.h"

#include "Int8.h"

#include "Error.h"

#include "util.h"

#include "GNURegex.h"

#include "debug.h"

using namespace std;

namespace libdap {

/** @brief Does this host use big-endian byte order? */

bool is_host_big_endian()

{

#ifdef COMPUTE_ENDIAN_AT_RUNTIME

    dods_int16 i = 0x0100;

    char *c = reinterpret_cast<char*>(&i);

    return *c;

#else

#if WORDS_BIGENDIAN

    return true;

#else

    return false;

#endif

#endif

}

/** Given a BaseType pointer, extract the string value it contains

 @param arg The BaseType pointer

 @return A C++ string

 @exception Error thrown if the referenced BaseType object does not contain

 a DAP String. */

string extract_string_argument(BaseType *arg)

{

    assert(arg);

    if (arg->type() != dods_str_c) throw Error(malformed_expr, "The function requires a string argument.");

    if (!arg->read_p())

        throw InternalErr(__FILE__, __LINE__,

                "The CE Evaluator built an argument list where some constants held no values.");

    return static_cast<Str*>(arg)->value();

}

template<class T> static void set_array_using_double_helper(Array *a, double *src, int src_len)

{

    assert(a);

    assert(src);

    assert(src_len > 0);

    vector<T> values(src_len);

    for (int i = 0; i < src_len; ++i)

        values[i] = (T) src[i];

    // This copies the values

    a->set_value(values, src_len);

}

/** Given an array that holds some sort of numeric data, load it with values

 using an array of doubles. This function makes several assumptions. First,

 it assumes the caller really wants to put the doubles into whatever types

 the array holds! Caveat emptor. Second, it assumes that if the size of

 source (\e src) array is different than the destination (\e dest) the

 caller has made a mistake. In that case it will throw an Error object.

 After setting the values, this method sets the \c read_p property for

 \e dest. Setting \e read_p tells the serialization methods in libdap

 that this variable already holds data values and, given that, the

 serialization code will not try to read the values.

 @note Support for DAP4 added.

 @param dest An Array. The values are written to this array, reusing

 its storage. Existing values are lost.

 @param src The source data.

 @param src_len The number of elements in the \e src array.

 @exception Error Thrown if \e dest is not a numeric-type array (Byte, ...,

 Float64) or if the number of elements in \e src does not match the number

 is \e dest. */

void set_array_using_double(Array *dest, double *src, int src_len)

{

    assert(dest);

    assert(src);

    assert(src_len > 0);

    // Simple types are Byte, ..., Float64, String and Url.

    if ((dest->type() == dods_array_c && !dest->var()->is_simple_type()) || dest->var()->type() == dods_str_c

            || dest->var()->type() == dods_url_c)

        throw InternalErr(__FILE__, __LINE__, "The function requires a numeric-type array argument.");

    // Test sizes. Note that Array::length() takes any constraint into account

    // when it returns the length. Even if this was removed, the 'helper'

    // function this uses calls Vector::val2buf() which uses Vector::width()

    // which in turn uses length().

    if (dest->length() != src_len)

        throw InternalErr(__FILE__, __LINE__,

                "The source and destination array sizes don't match (" + long_to_string(src_len) + " versus "

                        + long_to_string(dest->length()) + ").");

    // The types of arguments that the CE Parser will build for numeric

    // constants are limited to Uint32, Int32 and Float64. See ce_expr.y.

    // Expanded to work for any numeric type so it can be used for more than

    // just arguments.

    switch (dest->var()->type()) {

    case dods_byte_c:

        set_array_using_double_helper<dods_byte>(dest, src, src_len);

        break;

    case dods_uint16_c:

        set_array_using_double_helper<dods_uint16>(dest, src, src_len);

        break;

    case dods_int16_c:

        set_array_using_double_helper<dods_int16>(dest, src, src_len);

        break;

    case dods_uint32_c:

        set_array_using_double_helper<dods_uint32>(dest, src, src_len);

        break;

    case dods_int32_c:

        set_array_using_double_helper<dods_int32>(dest, src, src_len);

        break;

    case dods_float32_c:

        set_array_using_double_helper<dods_float32>(dest, src, src_len);

        break;

    case dods_float64_c:

        set_array_using_double_helper<dods_float64>(dest, src, src_len);

        break;

        // DAP4 support

    case dods_uint8_c:

        set_array_using_double_helper<dods_byte>(dest, src, src_len);

        break;

    case dods_int8_c:

        set_array_using_double_helper<dods_int8>(dest, src, src_len);

        break;

    case dods_uint64_c:

        set_array_using_double_helper<dods_uint64>(dest, src, src_len);

        break;

    case dods_int64_c:

        set_array_using_double_helper<dods_int64>(dest, src, src_len);

        break;

    default:

        throw InternalErr(__FILE__, __LINE__,

                "The argument list built by the CE parser contained an unsupported numeric type.");

    }

    // Set the read_p property.

    dest->set_read_p(true);

}

template<class T> static double *extract_double_array_helper(Array * a)

{

    assert(a);

    int length = a->length();

    vector<T> b(length);

    a->value(&b[0]);    // Extract the values of 'a' to 'b'

    double *dest = new double[length];

    for (int i = 0; i < length; ++i)

        dest[i] = (double) b[i];

    return dest;

}

/**

 * Given a pointer to an Array which holds a numeric type, extract the

 * values and return in an array of doubles. This function allocates the

 * array using 'new double[n]' so delete[] MUST be used when you are done

 * the data.

 *

 * @note Support added for DAP4.

 * @param a Extract value from this Array.

 * @return A C++/C array of doubles.

 */

double *extract_double_array(Array * a)

{

    assert(a);

    // Simple types are Byte, ..., Float64, String and Url.

    if ((a->type() == dods_array_c && !a->var()->is_simple_type()) || a->var()->type() == dods_str_c

            || a->var()->type() == dods_url_c)

        throw Error(malformed_expr, "The function requires a DAP numeric-type array argument.");

    if (!a->read_p())

        throw InternalErr(__FILE__, __LINE__, string("The Array '") + a->name() + "'does not contain values.");

    // The types of arguments that the CE Parser will build for numeric

    // constants are limited to Uint32, Int32 and Float64. See ce_expr.y.

    // Expanded to work for any numeric type so it can be used for more than

    // just arguments.

    switch (a->var()->type()) {

    case dods_byte_c:

        return extract_double_array_helper<dods_byte>(a);

    case dods_uint16_c:

        return extract_double_array_helper<dods_uint16>(a);

    case dods_int16_c:

        return extract_double_array_helper<dods_int16>(a);

    case dods_uint32_c:

        return extract_double_array_helper<dods_uint32>(a);

    case dods_int32_c:

        return extract_double_array_helper<dods_int32>(a);

    case dods_float32_c:

        return extract_double_array_helper<dods_float32>(a);

    case dods_float64_c:

        // Should not be copying these values, just read them,

        // but older code may depend on the return of this function

        // being something that should be deleted, so leave this

        // alone. jhrg 2/24/15

        return extract_double_array_helper<dods_float64>(a);

        // Support for DAP4

    case dods_uint8_c:

        return extract_double_array_helper<dods_byte>(a);

    case dods_int8_c:

        return extract_double_array_helper<dods_int8>(a);

    case dods_uint64_c:

        return extract_double_array_helper<dods_uint64>(a);

    case dods_int64_c:

        return extract_double_array_helper<dods_int64>(a);

    default:

        throw InternalErr(__FILE__, __LINE__,

                "The argument list built by the CE parser contained an unsupported numeric type.");

    }

}

// This helper function assumes 'dest' is the correct size. This should not

// be called when the Array 'a' is a Float64, since the values are already

// in a double array!

template<class T> static void extract_double_array_helper(Array * a, vector<double> &dest)

{

    assert(a);

    assert(dest.size() == (unsigned long )a->length());

    int length = a->length();

    vector<T> b(length);

    a->value(&b[0]);    // Extract the values of 'a' to 'b'

    for (int i = 0; i < length; ++i)

        dest[i] = (double) b[i];

}

/**

 * Given a pointer to an Array which holds a numeric type, extract the

 * values and return in an array of doubles. This function allocates the

 * array using 'new double[n]' so delete[] MUST be used when you are done

 * the data.

 *

 * @note Before you call this function, you must call read on the array,

 * or load the array with values and set the read_p property.

 *

 * @note Support added for DAP4.

 * @param a Extract value from this Array.

 * @param dest Put the values in this vector. A value-result parameter.

 * @return A C++/C array of doubles.

 */

void extract_double_array(Array *a, vector<double> &dest)

{

    assert(a);

    // Simple types are Byte, ..., Float64, String and Url.

    if ((a->type() == dods_array_c && !a->var()->is_simple_type()) || a->var()->type() == dods_str_c

            || a->var()->type() == dods_url_c)

        throw Error(malformed_expr, "The function requires a DAP numeric-type array argument.");

    if (!a->read_p())

        throw InternalErr(__FILE__, __LINE__, string("The Array '") + a->name() + "' does not contain values.");

    dest.resize(a->length());

    // The types of arguments that the CE Parser will build for numeric

    // constants are limited to Uint32, Int32 and Float64. See ce_expr.y.

    // Expanded to work for any numeric type so it can be used for more than

    // just arguments.

    switch (a->var()->type()) {

    case dods_byte_c:

        return extract_double_array_helper<dods_byte>(a, dest);

    case dods_uint16_c:

        return extract_double_array_helper<dods_uint16>(a, dest);

    case dods_int16_c:

        return extract_double_array_helper<dods_int16>(a, dest);

    case dods_uint32_c:

        return extract_double_array_helper<dods_uint32>(a, dest);

    case dods_int32_c:

        return extract_double_array_helper<dods_int32>(a, dest);

    case dods_float32_c:

        return extract_double_array_helper<dods_float32>(a, dest);

    case dods_float64_c:

        return a->value(&dest[0]);      // no need to copy the values

        // return extract_double_array_helper<dods_float64>(a, dest);

        // Support for DAP4

    case dods_uint8_c:

        return extract_double_array_helper<dods_byte>(a, dest);

    case dods_int8_c:

        return extract_double_array_helper<dods_int8>(a, dest);

    case dods_uint64_c:

        return extract_double_array_helper<dods_uint64>(a, dest);

    case dods_int64_c:

        return extract_double_array_helper<dods_int64>(a, dest);

    default:

        throw InternalErr(__FILE__, __LINE__,

                "The argument list built by the CE parser contained an unsupported numeric type.");

    }

}

/** Given a BaseType pointer, extract the numeric value it contains and return

 it in a C++ double.

 @note Support for DAP4 types added.

 @param arg The BaseType pointer

 @return A C++ double

 @exception Error thrown if the referenced BaseType object does not contain

 a DAP numeric value. */

double extract_double_value(BaseType *arg)

{

    assert(arg);

    // Simple types are Byte, ..., Float64, String and Url.

    if (!arg->is_simple_type() || arg->type() == dods_str_c || arg->type() == dods_url_c)

        throw Error(malformed_expr, "The function requires a numeric-type argument.");

    if (!arg->read_p())

        throw InternalErr(__FILE__, __LINE__,

                "The Evaluator built an argument list where some constants held no values.");

    // The types of arguments that the CE Parser will build for numeric

    // constants are limited to Uint32, Int32 and Float64. See ce_expr.y.

    // Expanded to work for any numeric type so it can be used for more than

    // just arguments.

    switch (arg->type()) {

    case dods_byte_c:

        return (double) (static_cast<Byte*>(arg)->value());

    case dods_uint16_c:

        return (double) (static_cast<UInt16*>(arg)->value());

    case dods_int16_c:

        return (double) (static_cast<Int16*>(arg)->value());

    case dods_uint32_c:

        return (double) (static_cast<UInt32*>(arg)->value());

    case dods_int32_c:

        return (double) (static_cast<Int32*>(arg)->value());

    case dods_float32_c:

        return (double) (static_cast<Float32*>(arg)->value());

    case dods_float64_c:

        return static_cast<Float64*>(arg)->value();

        // Support for DAP4 types.

    case dods_uint8_c:

        return (double) (static_cast<Byte*>(arg)->value());

    case dods_int8_c:

        return (double) (static_cast<Int8*>(arg)->value());

    case dods_uint64_c:

        return (double) (static_cast<UInt64*>(arg)->value());

    case dods_int64_c:

        return (double) (static_cast<Int64*>(arg)->value());

    default:

        throw InternalErr(__FILE__, __LINE__,

                "The argument list built by the parser contained an unsupported numeric type.");

    }

}

// Remove spaces from the start of a URL and from the start of any constraint

// expression it contains. 4/7/98 jhrg

/** Removed spaces from the front of a URL and also from the front of the CE.

 This function assumes that there are no holes in both the URL and the CE.

 It will remove \e leading space, but not other spaces.

 @param name The URL to process

 @return Returns a new string object that contains the pruned URL. */

string prune_spaces(const string &name)

{

    // If the URL does not even have white space return.

    if (name.find_first_of(' ') == name.npos)

        return name;

    else {

        // Strip leading spaces from http://...

        unsigned int i = name.find_first_not_of(' ');

        string tmp_name = name.substr(i);

        // Strip leading spaces from constraint part (following `?').

        unsigned int j = tmp_name.find('?') + 1;

        i = tmp_name.find_first_not_of(' ', j);

        tmp_name.erase(j, i - j);

        return tmp_name;

    }

}

// Compare elements in a list of (BaseType *)s and return true if there are

// no duplicate elements, otherwise return false.

bool unique_names(vector<BaseType *> l, const string &var_name, const string &type_name, string &msg)

{

    // copy the identifier names to a vector

    vector<string> names(l.size());

    int nelem = 0;

    typedef std::vector<BaseType *>::const_iterator citer;

    for (citer i = l.begin(); i != l.end(); i++) {

        assert(*i);

        names[nelem++] = (*i)->name();

        DBG(cerr << "NAMES[" << nelem - 1 << "]=" << names[nelem-1] << endl);

    }

    // sort the array of names

    sort(names.begin(), names.end());

    // sort the array of names

    sort(names.begin(), names.end());

    // look for any instance of consecutive names that are ==

    for (int j = 1; j < nelem; ++j) {

        if (names[j - 1] == names[j]) {

            ostringstream oss;

            oss << "The variable `" << names[j] << "' is used more than once in " << type_name << " `" << var_name

                    << "'";

            msg = oss.str();

            return false;

        }

    }

    return true;

}

const char *

libdap_root()

{

    return LIBDAP_ROOT;

}

/** Return the version string for this package.

 @note This function has C linkage so that it can be found using autoconf

 tests.

 @return The version string. */

extern "C" const char *

libdap_version()

{

    return PACKAGE_VERSION;

}

extern "C" const char *

libdap_name()

{

    return PACKAGE_NAME;

}

/**

 * Use the system time() function to get the current time. Return a string,

 * removing the trailing newline that time() includes in its response.

 * @return A C++ string with the current system time as formatted by time()

 */

string systime()

{

    time_t TimBin;

    if (time(&TimBin) == (time_t) -1)

        return string("time() error");

    else {

        char *ctime_value = ctime(&TimBin);

        if (ctime_value) {

            string TimStr = ctime_value;

            return TimStr.substr(0, TimStr.size() - 2); // remove the \n

        }

        else

            return "Unknown";

    }

}

/**

 * Downcase the source string. This function modifies its argument.

 * @param The string to modify

 */

void downcase(string &s)

{

    for (unsigned int i = 0; i < s.length(); i++)

        s[i] = tolower(s[i]);

}

/**

 * Is the string surrounded by double quotes?

 * @param s The source string

 * @reurn True if the string is quoted, false otherwise.

 */

bool is_quoted(const string &s)

{

    return (!s.empty() && s[0] == '\"' && s[s.length() - 1] == '\"');

}

/**

 * Return a new string that is not quoted. This will return a new string

 * regardless of whether the source string is actualy quoted.

 * @param s The source string

 * @return A new string without quotes

 */

string remove_quotes(const string &s)

{

    if (is_quoted(s))

        return s.substr(1, s.length() - 2);

    else

        return s;

}

/** Get the Type enumeration value which matches the given name. */

Type get_type(const char *name)

{

    if (strcmp(name, "Byte") == 0) return dods_byte_c;

    if (strcmp(name, "Char") == 0) return dods_char_c;

    if (strcmp(name, "Int8") == 0) return dods_int8_c;

    if (strcmp(name, "UInt8") == 0) return dods_uint8_c;

    if (strcmp(name, "Int16") == 0) return dods_int16_c;

    if (strcmp(name, "UInt16") == 0) return dods_uint16_c;

    if (strcmp(name, "Int32") == 0) return dods_int32_c;

    if (strcmp(name, "UInt32") == 0) return dods_uint32_c;

    if (strcmp(name, "Int64") == 0) return dods_int64_c;

    if (strcmp(name, "UInt64") == 0) return dods_uint64_c;

    if (strcmp(name, "Float32") == 0) return dods_float32_c;

    if (strcmp(name, "Float64") == 0) return dods_float64_c;

    if (strcmp(name, "String") == 0) return dods_str_c;

    // accept both spellings; this might be confusing since URL

    // could be filtered through code and come out Url. Don't know...

    // jhrg 8/15/13

    if (strcmp(name, "Url") == 0 || strcmp(name, "URL") == 0) return dods_url_c;

    if (strcmp(name, "Enum") == 0) return dods_enum_c;

    if (strcmp(name, "Opaque") == 0) return dods_opaque_c;

    if (strcmp(name, "Array") == 0) return dods_array_c;

    if (strcmp(name, "Structure") == 0) return dods_structure_c;

    if (strcmp(name, "Sequence") == 0) return dods_sequence_c;

    if (strcmp(name, "Grid") == 0) return dods_grid_c;

    return dods_null_c;

}

/**

 * @brief Returns the type of the class instance as a string.

 * Supports all DAP2 types and not the DAP4-only types. Also

 * returns Url (DAP2) and not "URL" (DAP4) for the URL type.

 * @param t The type code

 * @return The type name in a string

 */

string D2type_name(Type t)

{

    switch (t) {

    case dods_null_c:

        return string("Null");

    case dods_byte_c:

        return string("Byte");

    case dods_int16_c:

        return string("Int16");

    case dods_uint16_c:

        return string("UInt16");

    case dods_int32_c:

        return string("Int32");

    case dods_uint32_c:

        return string("UInt32");

    case dods_float32_c:

        return string("Float32");

    case dods_float64_c:

        return string("Float64");

    case dods_str_c:

        return string("String");

    case dods_url_c:

        return string("Url");

    case dods_array_c:

        return string("Array");

    case dods_structure_c:

        return string("Structure");

    case dods_sequence_c:

        return string("Sequence");

    case dods_grid_c:

        return string("Grid");

    default:

        throw InternalErr(__FILE__, __LINE__, "Unknown type.");

    }

}

/**

 * @brief Returns the type of the class instance as a string.

 * Supports all DAP4 types and not the DAP2-only types. Also

 * returns URL (DAP4) and not "Url" (DAP2) for the URL type.

 * @param t The type code

 * @return The type name in a string

 */

string D4type_name(Type t)

{

    switch (t) {

    case dods_null_c:

        return string("Null");

    case dods_byte_c:

        return string("Byte");

    case dods_char_c:

        return string("Char");

    case dods_int8_c:

        return string("Int8");

    case dods_uint8_c:

        return string("UInt8");

    case dods_int16_c:

        return string("Int16");

    case dods_uint16_c:

        return string("UInt16");

    case dods_int32_c:

        return string("Int32");

    case dods_uint32_c:

        return string("UInt32");

    case dods_int64_c:

        return string("Int64");

    case dods_uint64_c:

        return string("UInt64");

    case dods_enum_c:

        return string("Enum");

    case dods_float32_c:

        return string("Float32");

    case dods_float64_c:

        return string("Float64");

    case dods_str_c:

        return string("String");

    case dods_url_c:

        return string("URL");

    case dods_opaque_c:

        return string("Opaque");

    case dods_array_c:

        return string("Array");

    case dods_structure_c:

        return string("Structure");

    case dods_sequence_c:

        return string("Sequence");

    case dods_group_c:

        return string("Group");

    default:

        throw InternalErr(__FILE__, __LINE__, "Unknown type.");

    }

}

/** Return the type name. This function provides backward compatibility

 * for older code that predates, and has not been ported to, DAP4. It

 * is prejudiced toward DAP4, but if no D4 type name can be found, it

 * types D2. If neither would return a type name, and InternalErr object

 * is thrown.

 *

 * @param t The DAP2/DAP4 type

 * @return A string naming the type, suitable for humans

 * @exception InternalErr If not such type can be found

 */

string type_name(Type t)

{

    try {

        return D4type_name(t);

    }

    catch (...) {

        return D2type_name(t);

    }

}

/** @brief Returns true if the instance is a numeric, string or URL

 type variable.

 @return True if the instance is a scalar numeric, String or URL variable,

 False otherwise. Arrays (even of simple types) return False.

 @see is_vector_type() */

bool is_simple_type(Type t)

{

    switch (t) {

    case dods_byte_c:

    case dods_char_c:

    case dods_int8_c:

    case dods_uint8_c:

    case dods_int16_c:

    case dods_uint16_c:

    case dods_int32_c:

    case dods_uint32_c:

    case dods_int64_c:

    case dods_uint64_c:

    case dods_float32_c:

    case dods_float64_c:

    case dods_str_c:

    case dods_url_c:

    case dods_enum_c:

    case dods_opaque_c:

        return true;

    case dods_null_c:

    case dods_array_c:

    case dods_structure_c:

    case dods_sequence_c:

    case dods_grid_c:

    case dods_group_c:

    default:

        return false;

    }

    return false;

}

/** @brief Returns true if the instance is a vector (i.e., array) type

 variable.

 @return True if the instance is an Array, False otherwise. */

bool is_vector_type(Type t)

{

    switch (t) {

    case dods_null_c:

    case dods_byte_c:

    case dods_char_c:

    case dods_int8_c:

    case dods_uint8_c:

    case dods_int16_c:

    case dods_uint16_c:

    case dods_int32_c:

    case dods_uint32_c:

    case dods_int64_c:

    case dods_uint64_c:

    case dods_float32_c:

    case dods_float64_c:

    case dods_str_c:

    case dods_url_c:

    case dods_enum_c:

    case dods_opaque_c:

        return false;

    case dods_array_c:

        return true;

    case dods_structure_c:

    case dods_sequence_c:

    case dods_grid_c:

    case dods_group_c:

    default:

        return false;

    }

    return false;

}

/** @brief Returns true if the instance is a constructor (i.e., Structure,

 Sequence or Grid) type variable.

 @return True if the instance is a Structure, Sequence or Grid, False

 otherwise. */

bool is_constructor_type(Type t)

{

    switch (t) {

    case dods_null_c:

    case dods_byte_c:

    case dods_char_c:

    case dods_int8_c:

    case dods_uint8_c:

    case dods_int16_c:

    case dods_uint16_c:

    case dods_int32_c:

    case dods_uint32_c:

    case dods_int64_c:

    case dods_uint64_c: