Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

cppcheck

This commit is contained in:
Jan Steemann 2015-07-15 22:13:42 +02:00
parent 1428af9e49
commit 4bc188422a
7 changed files with 84 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
arangod/Aql/AqlItemBlock.cpp
View File

@ -96,14 +96,17 @@ AqlItemBlock::AqlItemBlock (Json const& json) {
// Now put in the data:
Json data(json.get("data"));
Json raw(json.get("raw"));
size_t posInRaw = 2;
size_t posInData = 0;
int64_t emptyRun = 0;
std::vector<AqlValue> madeHere;
madeHere.reserve(raw.size());
madeHere.emplace_back(); // an empty AqlValue
madeHere.emplace_back(); // another empty AqlValue, indices start w. 2
try {
size_t posInRaw = 2;
size_t posInData = 0;
int64_t emptyRun = 0;
for (RegisterId column = 0; column < _nrRegs; column++) {
for (size_t i = 0; i < _nrItems; i++) {
if (emptyRun > 0) {

12
arangod/Aql/Query.cpp
View File

@ -632,10 +632,10 @@ QueryResult Query::prepare (QueryRegistry* registry) {
////////////////////////////////////////////////////////////////////////////////
QueryResult Query::execute (QueryRegistry* registry) {
bool useQueryCache = canUseQueryCache();
uint64_t queryStringHash = 0;
try {
bool useQueryCache = canUseQueryCache();
uint64_t queryStringHash = 0;
if (useQueryCache) {
// hash the query
queryStringHash = hash();
@ -777,10 +777,10 @@ QueryResult Query::execute (QueryRegistry* registry) {
QueryResultV8 Query::executeV8 (v8::Isolate* isolate,
QueryRegistry* registry) {
bool useQueryCache = canUseQueryCache();
uint64_t queryStringHash = 0;
try {
bool useQueryCache = canUseQueryCache();
uint64_t queryStringHash = 0;
if (useQueryCache) {
// hash the query
queryStringHash = hash();

4
lib/HttpServer/HttpsCommTask.cpp
View File

@ -448,9 +448,9 @@ void HttpsCommTask::shutdownSsl (bool initShutdown) {
static int const SHUTDOWN_ITERATIONS = 10;
if (nullptr != _ssl) {
bool ok = false;
if (initShutdown) {
bool ok = false;
for (int i = 0; i < SHUTDOWN_ITERATIONS; ++i) {
ERR_clear_error();
int res = SSL_shutdown(_ssl);

20
lib/Scheduler/ListenTask.cpp
View File

@ -65,16 +65,15 @@ using namespace triagens::rest;
ListenTask::ListenTask (Endpoint* endpoint)
: Task("ListenTask"),
readWatcher(0),
readWatcher(nullptr),
_endpoint(endpoint),
acceptFailures(0) {
TRI_invalidatesocket(&_listenSocket);
bindSocket();
}
ListenTask::~ListenTask () {
if (readWatcher != 0) {
if (readWatcher != nullptr) {
_scheduler->uninstallEvent(readWatcher);
}
}
@ -86,16 +85,13 @@ ListenTask::~ListenTask () {
bool ListenTask::isBound () const {
MUTEX_LOCKER(changeLock);
return _endpoint != 0 && _endpoint->isConnected();
return _endpoint != nullptr && _endpoint->isConnected();
}
// -----------------------------------------------------------------------------
// Task methods
// -----------------------------------------------------------------------------
bool ListenTask::setup (Scheduler* scheduler, EventLoop loop) {
if (! isBound()) {
return true;
@ -151,8 +147,6 @@ bool ListenTask::setup (Scheduler* scheduler, EventLoop loop) {
return true;
}
void ListenTask::cleanup () {
if (_scheduler == nullptr) {
LOG_WARNING("In ListenTask::cleanup the scheduler has disappeared -- invalid pointer");
@ -163,8 +157,6 @@ void ListenTask::cleanup () {
readWatcher = nullptr;
}
bool ListenTask::handleEvent (EventToken token, EventType revents) {
if (token == readWatcher) {
if ((revents & EVENT_SOCKET_READ) == 0) {
@ -249,7 +241,7 @@ bool ListenTask::handleEvent (EventToken token, EventType revents) {
if (p != nullptr) {
info.clientAddress = p;
}
info.clientPort = addr->sin_port;
info.clientPort = addr->sin_port;
}
else if (type == Endpoint::DOMAIN_IPV6) {
const char *p;
@ -258,8 +250,8 @@ bool ListenTask::handleEvent (EventToken token, EventType revents) {
buf[INET6_ADDRSTRLEN] = '\0';
if (p != nullptr) {
info.clientAddress = p;
}
info.clientPort = addrmem.sin6_port;
}
info.clientPort = addrmem.sin6_port;
}
}

62
lib/Scheduler/SchedulerLibev.cpp
View File

@ -68,8 +68,10 @@ namespace {
struct ev_loop* loop;
Task* task;
AsyncWatcher ()
: Watcher(EVENT_ASYNC) {
AsyncWatcher (struct ev_loop* loop, Task* task)
: Watcher(EVENT_ASYNC),
loop(loop),
task(task) {
}
};
@ -78,7 +80,7 @@ namespace {
////////////////////////////////////////////////////////////////////////////////
void asyncCallback (struct ev_loop*, ev_async* w, int revents) {
AsyncWatcher* watcher = (AsyncWatcher*) w;
AsyncWatcher* watcher = (AsyncWatcher*) w; // cast from C type to C++ class
Task* task = watcher->task;
if (task != nullptr && (revents & EV_ASYNC) && task->isActive()) {
@ -102,8 +104,10 @@ namespace {
struct ev_loop* loop;
Task* task;
SocketWatcher ()
: Watcher(EVENT_SOCKET_READ) {
SocketWatcher (struct ev_loop* loop, Task* task)
: Watcher(EVENT_SOCKET_READ),
loop(loop),
task(task) {
}
};
@ -112,7 +116,7 @@ namespace {
////////////////////////////////////////////////////////////////////////////////
void socketCallback (struct ev_loop*, ev_io* w, int revents) {
SocketWatcher* watcher = (SocketWatcher*) w;
SocketWatcher* watcher = (SocketWatcher*) w; // cast from C type to C++ class
Task* task = watcher->task;
if (task != nullptr && task->isActive()) {
@ -138,8 +142,10 @@ namespace {
struct ev_loop* loop;
Task* task;
PeriodicWatcher ()
: Watcher(EVENT_PERIODIC) {
PeriodicWatcher (struct ev_loop* loop, Task* task)
: Watcher(EVENT_PERIODIC),
loop(loop),
task(task) {
}
};
@ -148,7 +154,7 @@ namespace {
////////////////////////////////////////////////////////////////////////////////
void periodicCallback (struct ev_loop*, ev_periodic* w, int revents) {
PeriodicWatcher* watcher = (PeriodicWatcher*) w;
PeriodicWatcher* watcher = (PeriodicWatcher*) w; // cast from C type to C++ class
Task* task = watcher->task;
if (task != nullptr && (revents & EV_PERIODIC) && task->isActive()) {
@ -164,8 +170,10 @@ namespace {
struct ev_loop* loop;
Task* task;
SignalWatcher ()
: Watcher(EVENT_SIGNAL) {
SignalWatcher (struct ev_loop* loop, Task* task)
: Watcher(EVENT_SIGNAL),
loop(loop),
task(task) {
}
};
@ -174,7 +182,7 @@ namespace {
////////////////////////////////////////////////////////////////////////////////
void signalCallback (struct ev_loop*, ev_signal* w, int revents) {
SignalWatcher* watcher = (SignalWatcher*) w;
SignalWatcher* watcher = (SignalWatcher*) w; // cast from C type to C++ class
Task* task = watcher->task;
if (task != nullptr && (revents & EV_SIGNAL) && task->isActive()) {
@ -190,8 +198,10 @@ namespace {
struct ev_loop* loop;
Task* task;
TimerWatcher ()
: Watcher(EVENT_TIMER) {
TimerWatcher (struct ev_loop* loop, Task* task)
: Watcher(EVENT_TIMER),
loop(loop),
task(task) {
}
};
@ -200,7 +210,7 @@ namespace {
////////////////////////////////////////////////////////////////////////////////
void timerCallback (struct ev_loop*, ev_timer* w, int revents) {
TimerWatcher* watcher = (TimerWatcher*) w;
TimerWatcher* watcher = (TimerWatcher*) w; // cast from C type to C++ class
Task* task = watcher->task;
if (task != nullptr && (revents & EV_TIMER) && task->isActive()) {
@ -377,7 +387,7 @@ void SchedulerLibev::uninstallEvent (EventToken watcher) {
switch (type) {
case EVENT_ASYNC: {
AsyncWatcher* w = (AsyncWatcher*) watcher;
AsyncWatcher* w = (AsyncWatcher*) watcher;
ev_async_stop(w->loop, (ev_async*) w);
delete w;
@ -424,9 +434,7 @@ void SchedulerLibev::uninstallEvent (EventToken watcher) {
////////////////////////////////////////////////////////////////////////////////
EventToken SchedulerLibev::installAsyncEvent (EventLoop loop, Task* task) {
AsyncWatcher* watcher = new AsyncWatcher;
watcher->loop = (struct ev_loop*) lookupLoop(loop);
watcher->task = task;
AsyncWatcher* watcher = new AsyncWatcher((struct ev_loop*) lookupLoop(loop), task);
ev_async* w = (ev_async*) watcher;
ev_async_init(w, asyncCallback);
@ -455,9 +463,7 @@ void SchedulerLibev::sendAsync (EventToken token) {
////////////////////////////////////////////////////////////////////////////////
EventToken SchedulerLibev::installPeriodicEvent (EventLoop loop, Task* task, double offset, double interval) {
PeriodicWatcher* watcher = new PeriodicWatcher;
watcher->loop = (struct ev_loop*) lookupLoop(loop);
watcher->task = task;
PeriodicWatcher* watcher = new PeriodicWatcher((struct ev_loop*) lookupLoop(loop), task);
ev_periodic* w = (ev_periodic*) watcher;
ev_periodic_init(w, periodicCallback, offset, interval, 0);
@ -487,9 +493,7 @@ void SchedulerLibev::rearmPeriodic (EventToken token, double offset, double inte
////////////////////////////////////////////////////////////////////////////////
EventToken SchedulerLibev::installSignalEvent (EventLoop loop, Task* task, int signal) {
SignalWatcher* watcher = new SignalWatcher;
watcher->loop = (struct ev_loop*) lookupLoop(loop);
watcher->task = task;
SignalWatcher* watcher = new SignalWatcher((struct ev_loop*) lookupLoop(loop), task);
ev_signal* w = (ev_signal*) watcher;
ev_signal_init(w, signalCallback, signal);
@ -509,9 +513,7 @@ EventToken SchedulerLibev::installSignalEvent (EventLoop loop, Task* task, int s
// ..........................................................................
EventToken SchedulerLibev::installSocketEvent (EventLoop loop, EventType type, Task* task, TRI_socket_t socket) {
SocketWatcher* watcher = new SocketWatcher;
watcher->loop = (struct ev_loop*) lookupLoop(loop);
watcher->task = task;
SocketWatcher* watcher = new SocketWatcher((struct ev_loop*) lookupLoop(loop), task);
int flags = 0;
@ -574,9 +576,7 @@ void SchedulerLibev::stopSocketEvents (EventToken token) {
////////////////////////////////////////////////////////////////////////////////
EventToken SchedulerLibev::installTimerEvent (EventLoop loop, Task* task, double timeout) {
TimerWatcher* watcher = new TimerWatcher;
watcher->loop = (struct ev_loop*) lookupLoop(loop);
watcher->task = task;
TimerWatcher* watcher = new TimerWatcher((struct ev_loop*) lookupLoop(loop), task);
ev_timer* w = (ev_timer*) watcher;
ev_timer_init(w, timerCallback, timeout, 0.0);

2
lib/V8/V8LineEditor.cpp
View File

@ -51,7 +51,7 @@ bool V8Completer::isComplete (std::string const& source, size_t lineno, size_t c
char const* ptr = source.c_str();
char const* end = ptr + source.length();
state = NORMAL;
LineParseState state = NORMAL;
while (ptr < end) {
if (state == DOUBLE_QUOTE) {

52
lib/V8/V8LineEditor.h
View File

@ -45,27 +45,39 @@ namespace triagens {
class V8Completer : public Completer {
enum {
NORMAL, // start
NORMAL_1, // from NORMAL: seen a single /
DOUBLE_QUOTE, // from NORMAL: seen a single "
DOUBLE_QUOTE_ESC, // from DOUBLE_QUOTE: seen a backslash
SINGLE_QUOTE, // from NORMAL: seen a single '
SINGLE_QUOTE_ESC, // from SINGLE_QUOTE: seen a backslash
BACKTICK, // from NORMAL: seen a single `
BACKTICK_ESC, // from BACKTICK: seen a backslash
MULTI_COMMENT, // from NORMAL_1: seen a *
MULTI_COMMENT_1, // from MULTI_COMMENT, seen a *
SINGLE_COMMENT // from NORMAL_1; seen a /
}
state;
public:
virtual bool isComplete (std::string const&,
size_t lineno,
size_t column);
V8Completer () {
}
~V8Completer () {
}
public:
bool isComplete (std::string const&,
size_t lineno,
size_t column) override final;
void getAlternatives (char const*,
std::vector<std::string>&) override final;
private:
enum LineParseState {
NORMAL, // start
NORMAL_1, // from NORMAL: seen a single /
DOUBLE_QUOTE, // from NORMAL: seen a single "
DOUBLE_QUOTE_ESC, // from DOUBLE_QUOTE: seen a backslash
SINGLE_QUOTE, // from NORMAL: seen a single '
SINGLE_QUOTE_ESC, // from SINGLE_QUOTE: seen a backslash
BACKTICK, // from NORMAL: seen a single `
BACKTICK_ESC, // from BACKTICK: seen a backslash
MULTI_COMMENT, // from NORMAL_1: seen a *
MULTI_COMMENT_1, // from MULTI_COMMENT, seen a *
SINGLE_COMMENT // from NORMAL_1; seen a /
};
virtual void getAlternatives (char const*,
std::vector<std::string>&);
};
// -----------------------------------------------------------------------------
@ -109,7 +121,7 @@ namespace triagens {
protected:
virtual void initializeShell ();
void initializeShell () override;
// -----------------------------------------------------------------------------
// --SECTION-- private variables