enh: clear assert remove tbuffer.h and .c file
This commit is contained in:
Alex Duan
parent
56c14f79a7
commit
35015452e5
|
|
@ -1,168 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program 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.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef _TD_UTIL_BUFFER_H_
|
||||
#define _TD_UTIL_BUFFER_H_
|
||||
|
||||
#include "os.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// usage example
|
||||
/*
|
||||
#include <stdio.h>
|
||||
#include "texception.h"
|
||||
|
||||
int32_t main( int32_t argc, char** argv ) {
|
||||
SBufferWriter bw = tbufInitWriter( NULL, false );
|
||||
|
||||
TRY( 1 ) {
|
||||
//--------------------- write ------------------------
|
||||
// reserve 1024 bytes for the buffer to improve performance
|
||||
tbufEnsureCapacity( &bw, 1024 );
|
||||
|
||||
// reserve space for the interger count
|
||||
size_t pos = tbufReserve( &bw, sizeof(int32_t) );
|
||||
// write 5 integers to the buffer
|
||||
for( int32_t i = 0; i < 5; i++) {
|
||||
tbufWriteInt32( &bw, i );
|
||||
}
|
||||
// write the integer count to buffer at reserved position
|
||||
tbufWriteInt32At( &bw, pos, 5 );
|
||||
|
||||
// write a string to the buffer
|
||||
tbufWriteString( &bw, "this is a string.\n" );
|
||||
// acquire the result and close the write buffer
|
||||
size_t size = tbufTell( &bw );
|
||||
char* data = tbufGetData( &bw, false );
|
||||
|
||||
//------------------------ read -----------------------
|
||||
SBufferReader br = tbufInitReader( data, size, false );
|
||||
// read & print out all integers
|
||||
int32_t count = tbufReadInt32( &br );
|
||||
for( int32_t i = 0; i < count; i++ ) {
|
||||
printf( "%d\n", tbufReadInt32(&br) );
|
||||
}
|
||||
// read & print out a string
|
||||
puts( tbufReadString(&br, NULL) );
|
||||
// try read another integer, this result in an error as there no this integer
|
||||
tbufReadInt32( &br );
|
||||
printf( "you should not see this message.\n" );
|
||||
} CATCH( code ) {
|
||||
printf( "exception code is: %d, you will see this message after print out 5 integers and a string.\n", code );
|
||||
} END_TRY
|
||||
|
||||
tbufCloseWriter( &bw );
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
typedef struct SBufferReader {
|
||||
bool endian;
|
||||
const char* data;
|
||||
size_t pos;
|
||||
size_t size;
|
||||
} SBufferReader;
|
||||
|
||||
typedef struct SBufferWriter {
|
||||
bool endian;
|
||||
char* data;
|
||||
size_t pos;
|
||||
size_t size;
|
||||
void* (*allocator)(void*, size_t);
|
||||
} SBufferWriter;
|
||||
|
||||
// common functions & macros for both reader & writer
|
||||
|
||||
#define tbufTell(buf) ((buf)->pos)
|
||||
|
||||
/* ------------------------ BUFFER WRITER FUNCTIONS AND MACROS ------------------------ */
|
||||
// *Allocator*, function to allocate memory, will use 'realloc' if NULL
|
||||
// *Endian*, if true, writer functions of primitive types will do 'hton' automatically
|
||||
#define tbufInitWriter(Allocator, Endian) \
|
||||
{ .endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator)) }
|
||||
|
||||
void tbufCloseWriter(SBufferWriter* buf);
|
||||
void tbufEnsureCapacity(SBufferWriter* buf, size_t size);
|
||||
size_t tbufReserve(SBufferWriter* buf, size_t size);
|
||||
char* tbufGetData(SBufferWriter* buf, bool takeOver);
|
||||
void tbufWrite(SBufferWriter* buf, const void* data, size_t size);
|
||||
void tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size);
|
||||
void tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len);
|
||||
void tbufWriteString(SBufferWriter* buf, const char* str);
|
||||
// the prototype of tbufWriteBinary and tbufWrite are identical
|
||||
// the difference is: tbufWriteBinary writes the length of the data to the buffer
|
||||
// first, then the actual data, which means the reader don't need to know data
|
||||
// size before read. Write only write the data itself, which means the reader
|
||||
// need to know data size before read.
|
||||
void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len);
|
||||
void tbufWriteBool(SBufferWriter* buf, bool data);
|
||||
void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data);
|
||||
void tbufWriteChar(SBufferWriter* buf, char data);
|
||||
void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data);
|
||||
void tbufWriteInt8(SBufferWriter* buf, int8_t data);
|
||||
void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data);
|
||||
void tbufWriteUint8(SBufferWriter* buf, uint8_t data);
|
||||
void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data);
|
||||
void tbufWriteInt16(SBufferWriter* buf, int16_t data);
|
||||
void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data);
|
||||
void tbufWriteUint16(SBufferWriter* buf, uint16_t data);
|
||||
void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data);
|
||||
void tbufWriteInt32(SBufferWriter* buf, int32_t data);
|
||||
void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data);
|
||||
void tbufWriteUint32(SBufferWriter* buf, uint32_t data);
|
||||
void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data);
|
||||
void tbufWriteInt64(SBufferWriter* buf, int64_t data);
|
||||
void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data);
|
||||
void tbufWriteUint64(SBufferWriter* buf, uint64_t data);
|
||||
void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data);
|
||||
void tbufWriteFloat(SBufferWriter* buf, float data);
|
||||
void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data);
|
||||
void tbufWriteDouble(SBufferWriter* buf, double data);
|
||||
void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data);
|
||||
|
||||
/* ------------------------ BUFFER READER FUNCTIONS AND MACROS ------------------------ */
|
||||
// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
|
||||
#define tbufInitReader(Data, Size, Endian) \
|
||||
{ .endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 : (Size)) }
|
||||
|
||||
size_t tbufSkip(SBufferReader* buf, size_t size);
|
||||
const char* tbufRead(SBufferReader* buf, size_t size);
|
||||
void tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size);
|
||||
const char* tbufReadString(SBufferReader* buf, size_t* len);
|
||||
size_t tbufReadToString(SBufferReader* buf, char* dst, size_t size);
|
||||
const char* tbufReadBinary(SBufferReader* buf, size_t* len);
|
||||
size_t tbufReadToBinary(SBufferReader* buf, void* dst, size_t size);
|
||||
bool tbufReadBool(SBufferReader* buf);
|
||||
char tbufReadChar(SBufferReader* buf);
|
||||
int8_t tbufReadInt8(SBufferReader* buf);
|
||||
uint8_t tbufReadUint8(SBufferReader* buf);
|
||||
int16_t tbufReadInt16(SBufferReader* buf);
|
||||
uint16_t tbufReadUint16(SBufferReader* buf);
|
||||
int32_t tbufReadInt32(SBufferReader* buf);
|
||||
uint32_t tbufReadUint32(SBufferReader* buf);
|
||||
int64_t tbufReadInt64(SBufferReader* buf);
|
||||
uint64_t tbufReadUint64(SBufferReader* buf);
|
||||
float tbufReadFloat(SBufferReader* buf);
|
||||
double tbufReadDouble(SBufferReader* buf);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /*_TD_UTIL_BUFFER_H_*/
|
||||
|
|
@ -1,425 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
|
||||
*
|
||||
* This program is free software: you can use, redistribute, and/or modify
|
||||
* it under the terms of the GNU Affero General Public License, version 3
|
||||
* or later ("AGPL"), as published by the Free Software Foundation.
|
||||
*
|
||||
* This program 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.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#define _DEFAULT_SOURCE
|
||||
#include "tbuffer.h"
|
||||
#include "texception.h"
|
||||
#include "tlog.h"
|
||||
|
||||
typedef union Un4B {
|
||||
uint32_t ui;
|
||||
float f;
|
||||
} Un4B;
|
||||
#if __STDC_VERSION__ >= 201112LL
|
||||
static_assert(sizeof(Un4B) == sizeof(uint32_t), "sizeof(Un4B) must equal to sizeof(uint32_t)");
|
||||
static_assert(sizeof(Un4B) == sizeof(float), "sizeof(Un4B) must equal to sizeof(float)");
|
||||
#endif
|
||||
|
||||
typedef union Un8B {
|
||||
uint64_t ull;
|
||||
double d;
|
||||
} Un8B;
|
||||
#if __STDC_VERSION__ >= 201112LL
|
||||
static_assert(sizeof(Un8B) == sizeof(uint64_t), "sizeof(Un8B) must equal to sizeof(uint64_t)");
|
||||
static_assert(sizeof(Un8B) == sizeof(double), "sizeof(Un8B) must equal to sizeof(double)");
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// reader functions
|
||||
|
||||
size_t tbufSkip(SBufferReader* buf, size_t size) {
|
||||
if ((buf->pos + size) > buf->size) {
|
||||
THROW(-1);
|
||||
}
|
||||
size_t old = buf->pos;
|
||||
buf->pos += size;
|
||||
return old;
|
||||
}
|
||||
|
||||
const char* tbufRead(SBufferReader* buf, size_t size) {
|
||||
const char* ret = buf->data + buf->pos;
|
||||
tbufSkip(buf, size);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size) {
|
||||
ASSERT(dst != NULL);
|
||||
// always using memcpy, leave optimization to compiler
|
||||
memcpy(dst, tbufRead(buf, size), size);
|
||||
}
|
||||
|
||||
static size_t tbufReadLength(SBufferReader* buf) {
|
||||
// maximum length is 65535, if larger length is required
|
||||
// this function and the corresponding write function need to be
|
||||
// revised.
|
||||
uint16_t l = tbufReadUint16(buf);
|
||||
return l;
|
||||
}
|
||||
|
||||
const char* tbufReadString(SBufferReader* buf, size_t* len) {
|
||||
size_t l = tbufReadLength(buf);
|
||||
const char* ret = buf->data + buf->pos;
|
||||
tbufSkip(buf, l + 1);
|
||||
if (ret[l] != 0) {
|
||||
THROW(-1);
|
||||
}
|
||||
if (len != NULL) {
|
||||
*len = l;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
size_t tbufReadToString(SBufferReader* buf, char* dst, size_t size) {
|
||||
assert(dst != NULL);
|
||||
size_t len;
|
||||
const char* str = tbufReadString(buf, &len);
|
||||
if (len >= size) {
|
||||
len = size - 1;
|
||||
}
|
||||
memcpy(dst, str, len);
|
||||
dst[len] = 0;
|
||||
return len;
|
||||
}
|
||||
|
||||
const char* tbufReadBinary(SBufferReader* buf, size_t* len) {
|
||||
size_t l = tbufReadLength(buf);
|
||||
const char* ret = buf->data + buf->pos;
|
||||
tbufSkip(buf, l);
|
||||
if (len != NULL) {
|
||||
*len = l;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
size_t tbufReadToBinary(SBufferReader* buf, void* dst, size_t size) {
|
||||
ASSERTS(dst != NULL, "dst != NULL");
|
||||
size_t len;
|
||||
const char* data = tbufReadBinary(buf, &len);
|
||||
if (len >= size) {
|
||||
len = size;
|
||||
}
|
||||
memcpy(dst, data, len);
|
||||
return len;
|
||||
}
|
||||
|
||||
bool tbufReadBool(SBufferReader* buf) {
|
||||
bool ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
char tbufReadChar(SBufferReader* buf) {
|
||||
char ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
int8_t tbufReadInt8(SBufferReader* buf) {
|
||||
int8_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint8_t tbufReadUint8(SBufferReader* buf) {
|
||||
uint8_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
int16_t tbufReadInt16(SBufferReader* buf) {
|
||||
int16_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
if (buf->endian) {
|
||||
return (int16_t)ntohs(ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint16_t tbufReadUint16(SBufferReader* buf) {
|
||||
uint16_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
if (buf->endian) {
|
||||
return ntohs(ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int32_t tbufReadInt32(SBufferReader* buf) {
|
||||
int32_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
if (buf->endian) {
|
||||
return (int32_t)ntohl(ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint32_t tbufReadUint32(SBufferReader* buf) {
|
||||
uint32_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
if (buf->endian) {
|
||||
return ntohl(ret);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int64_t tbufReadInt64(SBufferReader* buf) {
|
||||
int64_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
if (buf->endian) {
|
||||
return (int64_t)htobe64(ret); // TODO: ntohll
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint64_t tbufReadUint64(SBufferReader* buf) {
|
||||
uint64_t ret;
|
||||
tbufReadToBuffer(buf, &ret, sizeof(ret));
|
||||
if (buf->endian) {
|
||||
return htobe64(ret); // TODO: ntohll
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
float tbufReadFloat(SBufferReader* buf) {
|
||||
Un4B _un;
|
||||
tbufReadToBuffer(buf, &_un, sizeof(_un));
|
||||
if (buf->endian) {
|
||||
_un.ui = ntohl(_un.ui);
|
||||
}
|
||||
return _un.f;
|
||||
}
|
||||
|
||||
double tbufReadDouble(SBufferReader* buf) {
|
||||
Un8B _un;
|
||||
tbufReadToBuffer(buf, &_un, sizeof(_un));
|
||||
if (buf->endian) {
|
||||
_un.ull = htobe64(_un.ull);
|
||||
}
|
||||
return _un.d;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// writer functions
|
||||
|
||||
void tbufCloseWriter(SBufferWriter* buf) {
|
||||
taosMemoryFreeClear(buf->data);
|
||||
// (*buf->allocator)( buf->data, 0 ); // potential memory leak.
|
||||
buf->data = NULL;
|
||||
buf->pos = 0;
|
||||
buf->size = 0;
|
||||
}
|
||||
|
||||
void tbufEnsureCapacity(SBufferWriter* buf, size_t size) {
|
||||
size += buf->pos;
|
||||
if (size > buf->size) {
|
||||
size_t nsize = size + buf->size;
|
||||
char* data = (*buf->allocator)(buf->data, nsize);
|
||||
// TODO: the exception should be thrown by the allocator function
|
||||
if (data == NULL) {
|
||||
THROW(-1);
|
||||
}
|
||||
buf->data = data;
|
||||
buf->size = nsize;
|
||||
}
|
||||
}
|
||||
|
||||
size_t tbufReserve(SBufferWriter* buf, size_t size) {
|
||||
tbufEnsureCapacity(buf, size);
|
||||
size_t old = buf->pos;
|
||||
buf->pos += size;
|
||||
return old;
|
||||
}
|
||||
|
||||
char* tbufGetData(SBufferWriter* buf, bool takeOver) {
|
||||
char* ret = buf->data;
|
||||
if (takeOver) {
|
||||
buf->pos = 0;
|
||||
buf->size = 0;
|
||||
buf->data = NULL;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void tbufWrite(SBufferWriter* buf, const void* data, size_t size) {
|
||||
ASSERTS(data != NULL, "data != NULL");
|
||||
tbufEnsureCapacity(buf, size);
|
||||
memcpy(buf->data + buf->pos, data, size);
|
||||
buf->pos += size;
|
||||
}
|
||||
|
||||
void tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size) {
|
||||
ASSERTS(data != NULL, "data != NULL");
|
||||
// this function can only be called to fill the gap on previous writes,
|
||||
// so 'pos + size <= buf->pos' must be true
|
||||
ASSERTS(pos + size <= buf->pos, "pos + size <= buf->pos");
|
||||
memcpy(buf->data + pos, data, size);
|
||||
}
|
||||
|
||||
static void tbufWriteLength(SBufferWriter* buf, size_t len) {
|
||||
// maximum length is 65535, if larger length is required
|
||||
// this function and the corresponding read function need to be
|
||||
// revised.
|
||||
ASSERTS(len <= 0xffff, "len <= 0xffff");
|
||||
tbufWriteUint16(buf, (uint16_t)len);
|
||||
}
|
||||
|
||||
void tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len) {
|
||||
tbufWriteLength(buf, len);
|
||||
tbufWrite(buf, str, len);
|
||||
tbufWriteChar(buf, '\0');
|
||||
}
|
||||
|
||||
void tbufWriteString(SBufferWriter* buf, const char* str) { tbufWriteStringLen(buf, str, strlen(str)); }
|
||||
|
||||
void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len) {
|
||||
tbufWriteLength(buf, len);
|
||||
tbufWrite(buf, data, len);
|
||||
}
|
||||
|
||||
void tbufWriteBool(SBufferWriter* buf, bool data) { tbufWrite(buf, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteChar(SBufferWriter* buf, char data) { tbufWrite(buf, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteInt8(SBufferWriter* buf, int8_t data) { tbufWrite(buf, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteUint8(SBufferWriter* buf, uint8_t data) { tbufWrite(buf, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
|
||||
|
||||
void tbufWriteInt16(SBufferWriter* buf, int16_t data) {
|
||||
if (buf->endian) {
|
||||
data = (int16_t)htons(data);
|
||||
}
|
||||
tbufWrite(buf, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data) {
|
||||
if (buf->endian) {
|
||||
data = (int16_t)htons(data);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteUint16(SBufferWriter* buf, uint16_t data) {
|
||||
if (buf->endian) {
|
||||
data = htons(data);
|
||||
}
|
||||
tbufWrite(buf, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data) {
|
||||
if (buf->endian) {
|
||||
data = htons(data);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteInt32(SBufferWriter* buf, int32_t data) {
|
||||
if (buf->endian) {
|
||||
data = (int32_t)htonl(data);
|
||||
}
|
||||
tbufWrite(buf, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data) {
|
||||
if (buf->endian) {
|
||||
data = (int32_t)htonl(data);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteUint32(SBufferWriter* buf, uint32_t data) {
|
||||
if (buf->endian) {
|
||||
data = htonl(data);
|
||||
}
|
||||
tbufWrite(buf, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data) {
|
||||
if (buf->endian) {
|
||||
data = htonl(data);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteInt64(SBufferWriter* buf, int64_t data) {
|
||||
if (buf->endian) {
|
||||
data = (int64_t)htobe64(data);
|
||||
}
|
||||
tbufWrite(buf, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data) {
|
||||
if (buf->endian) {
|
||||
data = (int64_t)htobe64(data);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteUint64(SBufferWriter* buf, uint64_t data) {
|
||||
if (buf->endian) {
|
||||
data = htobe64(data);
|
||||
}
|
||||
tbufWrite(buf, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data) {
|
||||
if (buf->endian) {
|
||||
data = htobe64(data);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &data, sizeof(data));
|
||||
}
|
||||
|
||||
void tbufWriteFloat(SBufferWriter* buf, float data) {
|
||||
Un4B _un;
|
||||
_un.f = data;
|
||||
if (buf->endian) {
|
||||
_un.ui = htonl(_un.ui);
|
||||
}
|
||||
tbufWrite(buf, &_un, sizeof(_un));
|
||||
}
|
||||
|
||||
void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data) {
|
||||
Un4B _un;
|
||||
_un.f = data;
|
||||
if (buf->endian) {
|
||||
_un.ui = htonl(_un.ui);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &_un, sizeof(_un));
|
||||
}
|
||||
|
||||
void tbufWriteDouble(SBufferWriter* buf, double data) {
|
||||
Un8B _un;
|
||||
_un.d = data;
|
||||
if (buf->endian) {
|
||||
_un.ull = htobe64(_un.ull);
|
||||
}
|
||||
tbufWrite(buf, &_un, sizeof(_un));
|
||||
}
|
||||
|
||||
void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data) {
|
||||
Un8B _un;
|
||||
_un.d = data;
|
||||
if (buf->endian) {
|
||||
_un.ull = htobe64(_un.ull);
|
||||
}
|
||||
tbufWriteAt(buf, pos, &_un, sizeof(_un));
|
||||
}
|
||||
|
|
@ -258,7 +258,7 @@ static void rbtree_delete_fixup(rbtree_t *rbtree, rbnode_t *child, rbnode_t *chi
|
|||
child_parent->color = BLACK;
|
||||
return;
|
||||
}
|
||||
assert(sibling != RBTREE_NULL);
|
||||
ASSERTS(sibling != RBTREE_NULL, "sibling is NULL");
|
||||
|
||||
/* get a new sibling, by rotating at sibling. See which child
|
||||
of sibling is red */
|
||||
|
|
@ -288,11 +288,11 @@ static void rbtree_delete_fixup(rbtree_t *rbtree, rbnode_t *child, rbnode_t *chi
|
|||
sibling->color = child_parent->color;
|
||||
child_parent->color = BLACK;
|
||||
if (child_parent->right == child) {
|
||||
assert(sibling->left->color == RED);
|
||||
ASSERT(sibling->left->color == RED, "slibing->left->color=%d not equal RED", sibling->left->color);
|
||||
sibling->left->color = BLACK;
|
||||
rbtree_rotate_right(rbtree, child_parent);
|
||||
} else {
|
||||
assert(sibling->right->color == RED);
|
||||
ASSERTS(sibling->right->color == RED, "slibing->right->color=%d not equal RED", sibling->right->color);
|
||||
sibling->right->color = BLACK;
|
||||
rbtree_rotate_left(rbtree, child_parent);
|
||||
}
|
||||
|
|
@ -315,18 +315,18 @@ static void swap_np(rbnode_t **x, rbnode_t **y) {
|
|||
/** Update parent pointers of child trees of 'parent' */
|
||||
static void change_parent_ptr(rbtree_t *rbtree, rbnode_t *parent, rbnode_t *old, rbnode_t *new) {
|
||||
if (parent == RBTREE_NULL) {
|
||||
assert(rbtree->root == old);
|
||||
ASSERTS(rbtree->root == old, "root not equal old");
|
||||
if (rbtree->root == old) rbtree->root = new;
|
||||
return;
|
||||
}
|
||||
assert(parent->left == old || parent->right == old || parent->left == new || parent->right == new);
|
||||
ASSERT(parent->left == old || parent->right == old || parent->left == new || parent->right == new);
|
||||
if (parent->left == old) parent->left = new;
|
||||
if (parent->right == old) parent->right = new;
|
||||
}
|
||||
/** Update parent pointer of a node 'child' */
|
||||
static void change_child_ptr(rbtree_t *rbtree, rbnode_t *child, rbnode_t *old, rbnode_t *new) {
|
||||
if (child == RBTREE_NULL) return;
|
||||
assert(child->parent == old || child->parent == new);
|
||||
ASSERT(child->parent == old || child->parent == new);
|
||||
if (child->parent == old) child->parent = new;
|
||||
}
|
||||
|
||||
|
|
@ -371,7 +371,7 @@ rbnode_t *rbtree_delete(rbtree_t *rbtree, void *key) {
|
|||
|
||||
/* now delete to_delete (which is at the location where the smright previously was) */
|
||||
}
|
||||
assert(to_delete->left == RBTREE_NULL || to_delete->right == RBTREE_NULL);
|
||||
ASSERT(to_delete->left == RBTREE_NULL || to_delete->right == RBTREE_NULL);
|
||||
|
||||
if (to_delete->left != RBTREE_NULL)
|
||||
child = to_delete->left;
|
||||
|
|
|
|||
|
|
@ -466,7 +466,7 @@ static void taosLockList(int64_t *lockedBy) {
|
|||
static void taosUnlockList(int64_t *lockedBy) {
|
||||
int64_t tid = taosGetSelfPthreadId();
|
||||
if (atomic_val_compare_exchange_64(lockedBy, tid, 0) != tid) {
|
||||
assert(false);
|
||||
ASSERTS(false, "atomic_val_compare_exchange_64 tid failed");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -159,8 +159,7 @@ static void lockTimerList(timer_list_t* list) {
|
|||
static void unlockTimerList(timer_list_t* list) {
|
||||
int64_t tid = taosGetSelfPthreadId();
|
||||
if (atomic_val_compare_exchange_64(&(list->lockedBy), tid, 0) != tid) {
|
||||
assert(false);
|
||||
tmrError("%" PRId64 " trying to unlock a timer list not locked by current thread.", tid);
|
||||
ASSERTS(false, "%" PRId64 " trying to unlock a timer list not locked by current thread.", tid);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -506,7 +505,7 @@ bool taosTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* han
|
|||
}
|
||||
}
|
||||
|
||||
assert(timer->refCount == 1);
|
||||
ASSERTS(timer->refCount == 1, "timer refCount=%d not expected 1", timer->refCount);
|
||||
memset(timer, 0, sizeof(*timer));
|
||||
*pTmrId = (tmr_h)doStartTimer(timer, fp, mseconds, param, ctrl);
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ char **strsplit(char *z, const char *delim, int32_t *num) {
|
|||
if ((*num) >= size) {
|
||||
size = (size << 1);
|
||||
split = taosMemoryRealloc(split, POINTER_BYTES * size);
|
||||
assert(NULL != split);
|
||||
ASSERTS(NULL != split, "realloc memory failed. size=%d", POINTER_BYTES * size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -158,7 +158,9 @@ char *strtolower(char *dst, const char *src) {
|
|||
int32_t esc = 0;
|
||||
char quote = 0, *p = dst, c;
|
||||
|
||||
assert(dst != NULL);
|
||||
if (ASSERTS(dst != NULL, "dst is NULL")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (c = *src++; c; c = *src++) {
|
||||
if (esc) {
|
||||
|
|
@ -185,7 +187,10 @@ char *strntolower(char *dst, const char *src, int32_t n) {
|
|||
int32_t esc = 0;
|
||||
char quote = 0, *p = dst, c;
|
||||
|
||||
assert(dst != NULL);
|
||||
if (ASSERTS(dst != NULL, "dst is NULL")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (n == 0) {
|
||||
*p = 0;
|
||||
return dst;
|
||||
|
|
@ -214,7 +219,10 @@ char *strntolower(char *dst, const char *src, int32_t n) {
|
|||
char *strntolower_s(char *dst, const char *src, int32_t n) {
|
||||
char *p = dst, c;
|
||||
|
||||
assert(dst != NULL);
|
||||
if (ASSERTS(dst != NULL, "dst is NULL")) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (n == 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue