Index: trunk/psLib/src/db/psDB.c =================================================================== --- trunk/psLib/src/db/psDB.c (revision 10703) +++ trunk/psLib/src/db/psDB.c (revision 10708) @@ -12,6 +12,6 @@ * @author Joshua Hoblitt * - * @version $Revision: 1.121 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-12-14 01:37:55 $ + * @version $Revision: 1.122 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-12-14 05:13:58 $ * * Copyright (C) 2005-2006 Joshua Hoblitt, University of Hawaii @@ -38,4 +38,5 @@ #include "psString.h" #include "psTrace.h" +#include "psMetadataConfig.h" @@ -467,33 +468,33 @@ // conversion functions are a portability issue switch (type) { - case PS_TYPE_S8: - PS_STR_ARRAY_TO_PTYPE(column->data.S8, stringColumn, atoi, psS8, PS_TYPE_S8); - break; - case PS_TYPE_S16: - PS_STR_ARRAY_TO_PTYPE(column->data.S16, stringColumn, atoi, psS16, PS_TYPE_S16); - break; - case PS_TYPE_S32: - PS_STR_ARRAY_TO_PTYPE(column->data.S32, stringColumn, atoi, psS32, PS_TYPE_S32); - break; - case PS_TYPE_S64: - PS_STR_ARRAY_TO_PTYPE(column->data.S64, stringColumn, atoll, psS64, PS_TYPE_S64); - break; - case PS_TYPE_U8: - PS_STR_ARRAY_TO_PTYPE(column->data.U8, stringColumn, atoi, psU8, PS_TYPE_U8); - break; - case PS_TYPE_U16: - PS_STR_ARRAY_TO_PTYPE(column->data.U16, stringColumn, atoi, psU16, PS_TYPE_U16); - break; - case PS_TYPE_U32: - PS_STR_ARRAY_TO_PTYPE(column->data.U32, stringColumn, atoi, psU32, PS_TYPE_U32); - break; - case PS_TYPE_U64: - PS_STR_ARRAY_TO_PTYPE(column->data.U64, stringColumn, atoll, psU64, PS_TYPE_U64); - break; - case PS_TYPE_F32: - PS_STR_ARRAY_TO_PTYPE(column->data.F32, stringColumn, atof, psF32, PS_TYPE_F32); - break; - case PS_TYPE_F64: - PS_STR_ARRAY_TO_PTYPE(column->data.F64, stringColumn, atof, psF64, PS_TYPE_F64); + case PS_DATA_S8: + PS_STR_ARRAY_TO_PTYPE(column->data.S8, stringColumn, atoi, psS8, PS_DATA_S8); + break; + case PS_DATA_S16: + PS_STR_ARRAY_TO_PTYPE(column->data.S16, stringColumn, atoi, psS16, PS_DATA_S16); + break; + case PS_DATA_S32: + PS_STR_ARRAY_TO_PTYPE(column->data.S32, stringColumn, atoi, psS32, PS_DATA_S32); + break; + case PS_DATA_S64: + PS_STR_ARRAY_TO_PTYPE(column->data.S64, stringColumn, atoll, psS64, PS_DATA_S64); + break; + case PS_DATA_U8: + PS_STR_ARRAY_TO_PTYPE(column->data.U8, stringColumn, atoi, psU8, PS_DATA_U8); + break; + case PS_DATA_U16: + PS_STR_ARRAY_TO_PTYPE(column->data.U16, stringColumn, atoi, psU16, PS_DATA_U16); + break; + case PS_DATA_U32: + PS_STR_ARRAY_TO_PTYPE(column->data.U32, stringColumn, atoi, psU32, PS_DATA_U32); + break; + case PS_DATA_U64: + PS_STR_ARRAY_TO_PTYPE(column->data.U64, stringColumn, atoll, psU64, PS_DATA_U64); + break; + case PS_DATA_F32: + PS_STR_ARRAY_TO_PTYPE(column->data.F32, stringColumn, atof, psF32, PS_DATA_F32); + break; + case PS_DATA_F64: + PS_STR_ARRAY_TO_PTYPE(column->data.F64, stringColumn, atof, psF64, PS_DATA_F64); break; case PS_TYPE_C32: @@ -505,7 +506,7 @@ PS_STR_ARRAY_TO_PTYPE(column->data.C64, stringColumn, atof, psC64, PS_TYPE_C64); break; - case PS_TYPE_BOOL: + case PS_DATA_BOOL: // valid for psVector? - PS_STR_ARRAY_TO_PTYPE(column->data.U8, stringColumn, atoi, psU8, PS_TYPE_U8); + PS_STR_ARRAY_TO_PTYPE(column->data.U8, stringColumn, atoi, psU8, PS_DATA_U8); break; default: @@ -650,5 +651,5 @@ //psLogMsg( __func__, PS_LOG_INFO, "pType=[%ld]\n", pType ); - // if the ptype is PS_TYPE_PTR assume that it's a string and fetch the + // if the ptype is PS_DATA_PTR assume that it's a string and fetch the // column as an psArray of strings; otherwise fetch the column as a // psVector. @@ -990,30 +991,144 @@ len = fieldLength[i]; if (len) { - data = psAlloc(len+1); + // copy the data out of the result set struct + data = psAlloc(len + 1); memcpy(data, row[i], len); ((char*)data)[len] = '\0'; } else { + // if len is zero then the value is NULL + psTrace("psLib.db", PS_LOG_INFO, "database field name %s contains a NULL", field[i].name); data = psDBGetPTypeNaN(pType); - psMetadataAddStr(md, PS_LIST_TAIL, field[i].name, 0, "", data); + if (!psMetadataAdd(md, PS_LIST_TAIL, field[i].name, pType, "", data)) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } psFree(data); continue; } - // copy field data and convert NULLs to the appropriate NaN value switch (pType) { case PS_DATA_STRING: - psMetadataAddStr(md, PS_LIST_TAIL, field[i].name, 0, "", data); + if (!psMetadataAddStr(md, PS_LIST_TAIL, field[i].name, 0, "", data)) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_U8: + if (!psMetadataAddU8(md, PS_LIST_TAIL, field[i].name, 0, "",(psU8)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_U16: + if (!psMetadataAddU16(md, PS_LIST_TAIL, field[i].name, 0, "",(psU16)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_U32: + if (!psMetadataAddU32(md, PS_LIST_TAIL, field[i].name, 0, "",(psU32)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_U64: + if (!psMetadataAddU64(md, PS_LIST_TAIL, field[i].name, 0, "",(psU64)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_S8: + if (!psMetadataAddS8(md, PS_LIST_TAIL, field[i].name, 0, "", (psS8)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_S16: + if (!psMetadataAddS16(md, PS_LIST_TAIL, field[i].name, 0, "", (psS16)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } break; case PS_DATA_S32: - psMetadataAddS32(md, PS_LIST_TAIL, field[i].name, 0, "", atoll(data)); + if (!psMetadataAddS32(md, PS_LIST_TAIL, field[i].name, 0, "", (psS32)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } + break; + case PS_DATA_S64: + if (!psMetadataAddS64(md, PS_LIST_TAIL, field[i].name, 0, "", (psS64)atoll(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } break; case PS_DATA_F32: - psMetadataAddF32(md, PS_LIST_TAIL, field[i].name, 0, "", atof(data)); + if (!psMetadataAddF32(md, PS_LIST_TAIL, field[i].name, 0, "", atof(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } break; case PS_DATA_F64: - psMetadataAddF64(md, PS_LIST_TAIL, field[i].name, 0, "", atof(data)); + if (!psMetadataAddF64(md, PS_LIST_TAIL, field[i].name, 0, "", atof(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } break; case PS_DATA_BOOL: - psMetadataAdd(md, PS_LIST_TAIL, field[i].name, pType, "", atoi(data)); + if (!psMetadataAdd(md, PS_LIST_TAIL, field[i].name, pType, "", atoi(data))) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } break; case PS_DATA_TIME: @@ -1021,5 +1136,12 @@ // concept of a psTime with a NULL value if (!(char *)data) { - psMetadataAddTime(md, PS_LIST_TAIL, field[i].name, 0, "", NULL); + if (!psMetadataAddTime(md, PS_LIST_TAIL, field[i].name, 0, "", NULL)) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } } else { psTime *time = psTimeStrptime((char *)data, "%EY-%m-%d%t%T"); @@ -1031,7 +1153,15 @@ return NULL; } - psMetadataAddTime(md, PS_LIST_TAIL, field[i].name, 0, "", time); + if (!psMetadataAddTime(md, PS_LIST_TAIL, field[i].name, 0, "", time)) { + psError(PS_ERR_UNKNOWN, false, "Failed to add item %s", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; + } psFree(time); } + break; #if 0 // this is the procedure needed for stmt @@ -1056,9 +1186,33 @@ default: - // XXX: assume binary string ... - psMetadataAddStr(md, PS_LIST_TAIL, field[i].name, 0, "", data); + psError(PS_ERR_BAD_PARAMETER_TYPE , true, + "field name: %s FIXME: Only type of " + "PS_DATA_U8 (PS_DATA_U8), " + "PS_DATA_U16 (PS_DATA_U16), " + "PS_DATA_U32 (PS_DATA_U32), " + "PS_DATA_U64 (PS_DATA_U64), " + "PS_DATA_S8 (PS_DATA_S8), " + "PS_DATA_S16 (PS_DATA_S16), " + "PS_DATA_S32 (PS_DATA_S32), " + "PS_DATA_S64 (PS_DATA_S64), " + "PS_DATA_F32 (PS_DATA_F32), " + "PS_DATA_F64 (PS_DATA_F64), " + "PS_DATA_BOOL (PS_DATA_BOOL), " + "PS_DATA_STRING " + "and PS_DATA_TIME are supported.", field[i].name); + psFree(data); + psFree(md); + mysql_free_result(result); + psFree(resultSet); + return NULL; } psFree(data); + } + + if (psTraceGetLevel("psLib.db") >= PS_LOG_INFO) { + psString rowString = psMetadataConfigFormat(md); + psTrace("psLib.db", PS_LOG_INFO, "adding row to result set: %s", rowString); + psFree(rowString); } @@ -1069,4 +1223,5 @@ mysql_free_result(result); + return resultSet; @@ -1102,5 +1257,5 @@ // string switch (item->type) { - case PS_TYPE_U32: { + case PS_DATA_U32: { bind[i].length = 0; bind[i].buffer = &item->data.U32; @@ -1110,5 +1265,5 @@ break; } - case PS_TYPE_U64: { + case PS_DATA_U64: { bind[i].length = 0; bind[i].buffer = &item->data.U64; @@ -1118,5 +1273,5 @@ break; } - case PS_TYPE_S32: { + case PS_DATA_S32: { bind[i].length = 0; bind[i].buffer = &item->data.S32; @@ -1126,5 +1281,5 @@ break; } - case PS_TYPE_S64: { + case PS_DATA_S64: { bind[i].length = 0; bind[i].buffer = &item->data.S64; @@ -1134,5 +1289,5 @@ break; } - case PS_TYPE_F32: { + case PS_DATA_F32: { bind[i].length = 0; bind[i].buffer = &item->data.F32; @@ -1142,5 +1297,5 @@ break; } - case PS_TYPE_F64: { + case PS_DATA_F64: { bind[i].length = 0; bind[i].buffer = &item->data.F64; @@ -1150,5 +1305,5 @@ break; } - case PS_TYPE_BOOL: { + case PS_DATA_BOOL: { // XXX: ASC HACK NOTE (2005/06/03): set extreme bytes to the // boolean character value. sizeof(psBool)==4 which triggers @@ -1233,11 +1388,11 @@ psError(PS_ERR_BAD_PARAMETER_TYPE , true, "FIXME: Only type of " - "PS_TYPE_U32 (PS_DATA_S32), " - "PS_TYPE_U64 (PS_DATA_S64), " - "PS_TYPE_S32 (PS_DATA_S32), " - "PS_TYPE_S64 (PS_DATA_S64), " - "PS_TYPE_F32 (PS_DATA_F32), " - "PS_TYPE_F64 (PS_DATA_F64), " - "PS_TYPE_BOOL (PS_DATA_BOOL), " + "PS_DATA_U32 (PS_DATA_S32), " + "PS_DATA_U64 (PS_DATA_S64), " + "PS_DATA_S32 (PS_DATA_S32), " + "PS_DATA_S64 (PS_DATA_S64), " + "PS_DATA_F32 (PS_DATA_F32), " + "PS_DATA_F64 (PS_DATA_F64), " + "PS_DATA_BOOL (PS_DATA_BOOL), " "PS_DATA_STRING " "and PS_DATA_TIME are supported."); @@ -1916,17 +2071,17 @@ // no support for CHAR, TEXT or GLOB - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S8, "TINYINT"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S16, "SMALLINT"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S32, "INT"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S64, "BIGINT"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U8, "TINYINT UNSIGNED"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U16, "SMALLINT UNSIGNED"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U32, "INT UNSIGNED" ); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U64, "BIGINT UNSIGNED"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_F32, "FLOAT"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_F64, "DOUBLE"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_S8, "TINYINT"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_S16, "SMALLINT"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_S32, "INT"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_S64, "BIGINT"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_U8, "TINYINT UNSIGNED"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_U16, "SMALLINT UNSIGNED"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_U32, "INT UNSIGNED" ); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_U64, "BIGINT UNSIGNED"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_F32, "FLOAT"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_F64, "DOUBLE"); psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported"); psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported"); - psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_BOOL,"TINYINT"); + psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_BOOL,"TINYINT"); psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_STRING, "VARCHAR"); psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_TIME, "DATETIME"); @@ -2060,21 +2215,21 @@ pTypeToMysqlLookupTable = psHashAlloc(14); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S8, psDBMySQLTypeAlloc(MYSQL_TYPE_TINY, false)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S16, psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT, false)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S32, psDBMySQLTypeAlloc(MYSQL_TYPE_LONG, false)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S64, psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG, false)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U8, psDBMySQLTypeAlloc(MYSQL_TYPE_TINY, true)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U16, psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT, true)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U32, psDBMySQLTypeAlloc(MYSQL_TYPE_LONG, true)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U64, psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG, true)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_F32, psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT, false)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_F64, psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_S8, psDBMySQLTypeAlloc(MYSQL_TYPE_TINY, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_S16, psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_S32, psDBMySQLTypeAlloc(MYSQL_TYPE_LONG, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_S64, psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_U8, psDBMySQLTypeAlloc(MYSQL_TYPE_TINY, true)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_U16, psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT, true)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_U32, psDBMySQLTypeAlloc(MYSQL_TYPE_LONG, true)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_U64, psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG, true)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_F32, psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_F64, psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE, false)); // bogus type psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C32, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false)); // bogus type psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C64, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false)); - psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_BOOL, psDBMySQLTypeAlloc(MYSQL_TYPE_TINY, true)); - // XXX: removed PS_TYPE_PTR, can this be removed too? - // psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_PTR, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false)); + psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_BOOL, psDBMySQLTypeAlloc(MYSQL_TYPE_TINY, true)); + // XXX: removed PS_DATA_PTR, can this be removed too? + // psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_PTR, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false)); psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_STRING, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false)); @@ -2160,32 +2315,32 @@ switch (pType) { - case PS_TYPE_S8: + case PS_DATA_S8: PS_NAN_ALLOC(myNaN, psS8, PS_MAX_S8); break; - case PS_TYPE_S16: + case PS_DATA_S16: PS_NAN_ALLOC(myNaN, psS16, PS_MAX_S16); break; - case PS_TYPE_S32: + case PS_DATA_S32: PS_NAN_ALLOC(myNaN, psS32, PS_MAX_S32); break; - case PS_TYPE_S64: + case PS_DATA_S64: PS_NAN_ALLOC(myNaN, psS64, PS_MAX_S64); break; - case PS_TYPE_U8: + case PS_DATA_U8: PS_NAN_ALLOC(myNaN, psU8, PS_MAX_U8); break; - case PS_TYPE_U16: + case PS_DATA_U16: PS_NAN_ALLOC(myNaN, psU16, PS_MAX_U16); break; - case PS_TYPE_U32: + case PS_DATA_U32: PS_NAN_ALLOC(myNaN, psU32, PS_MAX_U32); break; - case PS_TYPE_U64: + case PS_DATA_U64: PS_NAN_ALLOC(myNaN, psU64, PS_MAX_U64); break; - case PS_TYPE_F32: + case PS_DATA_F32: PS_NAN_ALLOC(myNaN, psF32, NAN); break; - case PS_TYPE_F64: + case PS_DATA_F64: PS_NAN_ALLOC(myNaN, psF64, NAN); break; @@ -2198,5 +2353,5 @@ PS_NAN_ALLOC(myNaN, psC64, NAN); break; - case PS_TYPE_BOOL: + case PS_DATA_BOOL: // XXX: what is NaN for a bool? PS_NAN_ALLOC(myNaN, psU8, PS_MAX_U8); @@ -2215,32 +2370,32 @@ switch (pType) { - case PS_TYPE_S8: + case PS_DATA_S8: isNaN = PS_IS_NAN(psS8, data, PS_MAX_S8); break; - case PS_TYPE_S16: + case PS_DATA_S16: isNaN = PS_IS_NAN(psS16, data, PS_MAX_S16); break; - case PS_TYPE_S32: + case PS_DATA_S32: isNaN = PS_IS_NAN(psS32, data, PS_MAX_S32); break; - case PS_TYPE_S64: + case PS_DATA_S64: isNaN = PS_IS_NAN(psS64, data, PS_MAX_S64); break; - case PS_TYPE_U8: + case PS_DATA_U8: isNaN = PS_IS_NAN(psU8, data, PS_MAX_U8); break; - case PS_TYPE_U16: + case PS_DATA_U16: isNaN = PS_IS_NAN(psU16, data, PS_MAX_U16); break; - case PS_TYPE_U32: + case PS_DATA_U32: isNaN = PS_IS_NAN(psU32, data, PS_MAX_U32); break; - case PS_TYPE_U64: + case PS_DATA_U64: isNaN = PS_IS_NAN(psU64, data, PS_MAX_U64); break; - case PS_TYPE_F32: + case PS_DATA_F32: isNaN = PS_IS_NAN(psF32, data, NAN); break; - case PS_TYPE_F64: + case PS_DATA_F64: isNaN = PS_IS_NAN(psF64, data, NAN); break; @@ -2253,5 +2408,5 @@ isNaN = PS_IS_NAN(psC64, data, NAN); break; - case PS_TYPE_BOOL: + case PS_DATA_BOOL: // XXX: what is NaN for a bool? isNaN = PS_IS_NAN(psU8, data, PS_MAX_U8);