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

Merge branch 'devel' of github.com:triAGENS/ArangoDB into devel

This commit is contained in:
Michael Hackstein 2014-07-18 17:00:00 +02:00
parent 2999212360 69c1a399b4
commit 3b78858360
9 changed files with 107 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
arangod/Ahuacatl/ahuacatl-ast-node.cpp
View File

@ -44,22 +44,32 @@
/// @brief shortcut macro to create a new node or fail in case of OOM
////////////////////////////////////////////////////////////////////////////////
#define CREATE_NODE(type) \
TRI_aql_node_t* node = (TRI_aql_node_t*) \
TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_node_t), false); \
if (node == NULL) { \
TRI_SetErrorContextAql( \
__FILE__, \
__LINE__, \
context, \
TRI_ERROR_OUT_OF_MEMORY, \
NULL); \
return NULL; \
} \
\
node->_type = type; \
TRI_InitVectorPointer(&node->_members, TRI_UNKNOWN_MEM_ZONE); \
inline TRI_aql_node_t* CREATE_NODE_FUNC(TRI_aql_node_type_e type,
TRI_aql_context_t* context) {
TRI_aql_node_t* node;
try {
node = new TRI_aql_node_t();
}
catch (std::exception&) {
node = nullptr;
}
if (node == nullptr) {
TRI_SetErrorContextAql(
__FILE__,
__LINE__,
context,
TRI_ERROR_OUT_OF_MEMORY,
nullptr);
return nullptr;
}
node->_type = type;
TRI_InitVectorPointer(&node->_members, TRI_UNKNOWN_MEM_ZONE);
TRI_RegisterNodeContextAql(context, node);
return node;
}
#define CREATE_NODE(type) TRI_aql_node_t* node = CREATE_NODE_FUNC(type, context);
////////////////////////////////////////////////////////////////////////////////
/// @brief add a sub node to a node
@ -206,10 +216,12 @@ static TRI_aql_node_t* CreateNodeUserFcall (TRI_aql_context_t* const context,
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeNopAql (void) {
TRI_aql_node_t* node = (TRI_aql_node_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_node_t), false);
if (node == NULL) {
return NULL;
TRI_aql_node_t* node;
try {
node = new TRI_aql_node_t;
}
catch (std::exception&) {
return nullptr;
}
node->_type = TRI_AQL_NODE_NOP;
@ -228,20 +240,29 @@ TRI_aql_node_t* TRI_CreateNodeReturnEmptyAql (void) {
TRI_aql_node_t* list;
int res;
node = (TRI_aql_node_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_node_t), false);
try {
node = new TRI_aql_node_t();
}
catch (std::exception&) {
node = nullptr;
}
if (node == NULL) {
return NULL;
if (node == nullptr) {
return nullptr;
}
node->_type = TRI_AQL_NODE_RETURN_EMPTY;
list = (TRI_aql_node_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_node_t), false);
try {
list = new TRI_aql_node_t();
}
catch (std::exception&) {
list = nullptr;
}
if (list == NULL) {
TRI_Free(TRI_UNKNOWN_MEM_ZONE, node);
return NULL;
if (list == nullptr) {
delete node;
return nullptr;
}
list->_type = TRI_AQL_NODE_LIST;
@ -251,8 +272,8 @@ TRI_aql_node_t* TRI_CreateNodeReturnEmptyAql (void) {
if (res != TRI_ERROR_NO_ERROR) {
TRI_DestroyVectorPointer(&list->_members);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, list);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, node);
delete list;
delete node;
return NULL;
}
@ -262,8 +283,8 @@ TRI_aql_node_t* TRI_CreateNodeReturnEmptyAql (void) {
if (res != TRI_ERROR_NO_ERROR) {
TRI_DestroyVectorPointer(&node->_members);
TRI_DestroyVectorPointer(&list->_members);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, list);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, node);
delete list;
delete node;
return NULL;
}

6
arangod/Ahuacatl/ahuacatl-codegen.cpp
View File

@ -2985,7 +2985,7 @@ static void ProcessNode (TRI_aql_codegen_js_t* const generator, const TRI_aql_no
static TRI_aql_codegen_register_t CreateCode (TRI_aql_codegen_js_t* generator) {
TRI_aql_codegen_register_t startRegister = IncRegister(generator);
TRI_vector_pointer_t* statements;
std::vector<TRI_aql_node_t*>* statements;
size_t i, n;
StartScope(generator, &generator->_buffer, TRI_AQL_SCOPE_MAIN, 0, 0, 0, startRegister, NULL);
@ -2997,11 +2997,11 @@ static TRI_aql_codegen_register_t CreateCode (TRI_aql_codegen_js_t* generator) {
InitList(generator, startRegister);
statements = &generator->_context->_statements->_statements;
n = statements->_length;
n = statements->size();
for (i = 0; i < n; ++i) {
TRI_aql_node_t* node;
node = static_cast<TRI_aql_node_t*>(TRI_AtVectorPointer(statements, i));
node = statements->at(i);
ProcessNode(generator, node);
}

2
arangod/Ahuacatl/ahuacatl-context.cpp
View File

@ -131,7 +131,7 @@ static void FreeNodes (TRI_aql_context_t* const context) {
}
// free node itself
TRI_Free(TRI_UNKNOWN_MEM_ZONE, node);
delete node;
}
TRI_DestroyVectorPointer(&context->_memory._nodes);

4
arangod/Ahuacatl/ahuacatl-context.h
View File

@ -37,7 +37,7 @@
#include "Ahuacatl/ahuacatl-error.h"
#include "Ahuacatl/ahuacatl-statementlist.h"
struct TRI_aql_node_s;
struct TRI_aql_node_t;
struct TRI_aql_parser_s;
struct TRI_json_s;
struct TRI_vocbase_s;
@ -94,7 +94,7 @@ typedef struct TRI_aql_context_s {
TRI_aql_query_type_e _type;
char* _writeCollection;
struct TRI_aql_node_s* _writeOptions;
struct TRI_aql_node_t* _writeOptions;
struct TRI_json_s* _userOptions;
bool _fullCount;

5
arangod/Ahuacatl/ahuacatl-node.h
View File

@ -211,12 +211,11 @@ TRI_aql_value_t;
/// @brief an abstract AST node type
////////////////////////////////////////////////////////////////////////////////
typedef struct TRI_aql_node_s {
struct TRI_aql_node_t {
TRI_vector_pointer_t _members;
TRI_aql_node_type_e _type;
TRI_aql_value_t _value;
}
TRI_aql_node_t;
};
// -----------------------------------------------------------------------------
// --SECTION-- public functions

4
arangod/Ahuacatl/ahuacatl-statement-dump.h
View File

@ -32,7 +32,7 @@
#include "Basics/Common.h"
struct TRI_aql_statement_list_s;
struct TRI_aql_statement_list_t;
// -----------------------------------------------------------------------------
// --SECTION-- public types
@ -55,7 +55,7 @@ TRI_aql_dump_t;
/// @brief dump statement list
////////////////////////////////////////////////////////////////////////////////
void TRI_DumpStatementsAql (struct TRI_aql_statement_list_s* const);
void TRI_DumpStatementsAql (struct TRI_aql_statement_list_t* const);
#endif

11
arangod/Ahuacatl/ahuacatl-statement-walker.cpp
View File

@ -53,7 +53,7 @@ static void VisitStatement (TRI_aql_statement_walker_t* const walker,
TRI_aql_node_t* node;
TRI_aql_node_t* modified;
node = (TRI_aql_node_t*) TRI_AtVectorPointer(&walker->_statements->_statements, position);
node = walker->_statements->_statements[position];
TRI_ASSERT(node);
modified = func(walker, node);
@ -62,7 +62,7 @@ static void VisitStatement (TRI_aql_statement_walker_t* const walker,
modified = TRI_GetDummyNopNodeAql();
}
walker->_statements->_statements._buffer[position] = modified;
walker->_statements->_statements[position] = modified;
}
}
@ -108,13 +108,13 @@ static void RunWalk (TRI_aql_statement_walker_t* const walker) {
size_t i, n;
TRI_ASSERT(walker);
n = walker->_statements->_statements._length;
n = walker->_statements->_statements.size();
for (i = 0; i < n; ++i) {
TRI_aql_node_t* node;
TRI_aql_node_type_e nodeType;
node = (TRI_aql_node_t*) TRI_AtVectorPointer(&walker->_statements->_statements, i);
node = walker->_statements->_statements[i];
if (! node) {
continue;
@ -131,8 +131,7 @@ static void RunWalk (TRI_aql_statement_walker_t* const walker) {
if (walker->preVisitStatement != NULL) {
// this might change the node ptr
VisitStatement(walker, i, walker->preVisitStatement);
node = static_cast<TRI_aql_node_t*>
(walker->_statements->_statements._buffer[i]);
node = walker->_statements->_statements[i];
}

58
arangod/Ahuacatl/ahuacatl-statementlist.cpp
View File

@ -60,7 +60,7 @@ static TRI_aql_node_t* DummyReturnEmptyNode;
static inline TRI_aql_node_t* StatementAt (const TRI_aql_statement_list_t* const list,
const size_t position) {
return (TRI_aql_node_t*) TRI_AtVectorPointer(&list->_statements, position);
return list->_statements[position];
}
////////////////////////////////////////////////////////////////////////////////
@ -73,7 +73,7 @@ static size_t InvalidateEmptyScope (TRI_aql_statement_list_t* const list,
size_t scopes;
TRI_ASSERT(list);
n = list->_statements._length;
n = list->_statements.size();
i = position;
scopes = 0;
@ -83,10 +83,10 @@ static size_t InvalidateEmptyScope (TRI_aql_statement_list_t* const list,
if (i == position) {
TRI_ASSERT(type == TRI_AQL_NODE_SCOPE_START);
list->_statements._buffer[i] = DummyReturnEmptyNode;
list->_statements[i] = DummyReturnEmptyNode;
}
else {
list->_statements._buffer[i] = TRI_GetDummyNopNodeAql();
list->_statements[i] = TRI_GetDummyNopNodeAql();
}
++i;
@ -118,13 +118,17 @@ static size_t InvalidateEmptyScope (TRI_aql_statement_list_t* const list,
TRI_aql_statement_list_t* TRI_CreateStatementListAql (void) {
TRI_aql_statement_list_t* list;
list = (TRI_aql_statement_list_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_aql_statement_list_t), false);
try {
list = new TRI_aql_statement_list_t();
}
catch (std::exception&) {
list = nullptr;
}
if (list == NULL) {
return NULL;
}
TRI_InitVectorPointer(&list->_statements, TRI_UNKNOWN_MEM_ZONE);
list->_currentLevel = 0;
return list;
@ -139,8 +143,7 @@ void TRI_FreeStatementListAql (TRI_aql_statement_list_t* const list) {
return;
}
TRI_DestroyVectorPointer(&list->_statements);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, list);
delete list;
}
// -----------------------------------------------------------------------------
@ -163,17 +166,17 @@ void TRI_GlobalInitStatementListAql (void) {
void TRI_GlobalFreeStatementListAql (void) {
if (DummyNopNode != NULL) {
TRI_DestroyVectorPointer(&DummyNopNode->_members);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, DummyNopNode);
delete DummyNopNode;
}
if (DummyReturnEmptyNode != NULL) {
TRI_aql_node_t* list = TRI_AQL_NODE_MEMBER(DummyReturnEmptyNode, 0);
TRI_DestroyVectorPointer(&list->_members);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, list);
delete list;
TRI_DestroyVectorPointer(&DummyReturnEmptyNode->_members);
TRI_Free(TRI_UNKNOWN_MEM_ZONE, DummyReturnEmptyNode);
delete DummyReturnEmptyNode;
}
}
@ -200,7 +203,7 @@ void TRI_PulloutStatementListAql (TRI_aql_statement_list_t* const list) {
TRI_ASSERT(list);
i = 0;
n = list->_statements._length;
n = list->_statements.size();
while (i < n) {
TRI_aql_node_t* node = StatementAt(list, i);
@ -245,7 +248,7 @@ void TRI_PulloutStatementListAql (TRI_aql_statement_list_t* const list) {
}
// insert a dummy node in place of the moved node
list->_statements._buffer[j + inserted + 1] = TRI_GetDummyNopNodeAql();
list->_statements[j + inserted + 1] = TRI_GetDummyNopNodeAql();
// next
++j;
@ -272,14 +275,16 @@ void TRI_PulloutStatementListAql (TRI_aql_statement_list_t* const list) {
bool TRI_InsertStatementListAql (TRI_aql_statement_list_t* const list,
TRI_aql_node_t* const node,
const size_t position) {
int res;
TRI_ASSERT(list != NULL);
TRI_ASSERT(node != NULL);
res = TRI_InsertVectorPointer(&list->_statements, node, position);
return res == TRI_ERROR_NO_ERROR;
try {
list->_statements.insert(list->_statements.begin() + position, node);
}
catch (std::exception&) {
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
@ -289,7 +294,6 @@ bool TRI_InsertStatementListAql (TRI_aql_statement_list_t* const list,
bool TRI_AppendStatementListAql (TRI_aql_statement_list_t* const list,
TRI_aql_node_t* const node) {
TRI_aql_node_type_e type;
int res;
TRI_ASSERT(list != NULL);
TRI_ASSERT(node != NULL);
@ -305,9 +309,13 @@ bool TRI_AppendStatementListAql (TRI_aql_statement_list_t* const list,
--list->_currentLevel;
}
res = TRI_PushBackVectorPointer(&list->_statements, node);
return res == TRI_ERROR_NO_ERROR;
try {
list->_statements.push_back(node);
}
catch (std::exception&) {
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
@ -321,7 +329,7 @@ void TRI_CompactStatementListAql (TRI_aql_statement_list_t* const list) {
i = 0;
j = 0;
n = list->_statements._length;
n = list->_statements.size();
while (i < n) {
TRI_aql_node_t* node = StatementAt(list, i);
@ -347,11 +355,11 @@ void TRI_CompactStatementListAql (TRI_aql_statement_list_t* const list) {
}
*/
list->_statements._buffer[j++] = node;
list->_statements[j++] = node;
++i;
}
list->_statements._length = j;
list->_statements.resize(j);
}
// -----------------------------------------------------------------------------

15
arangod/Ahuacatl/ahuacatl-statementlist.h
View File

@ -33,17 +33,16 @@
#include "Basics/Common.h"
#include "BasicsC/vector.h"
struct TRI_aql_node_s;
struct TRI_aql_node_t;
// -----------------------------------------------------------------------------
// --SECTION-- public types
// -----------------------------------------------------------------------------
typedef struct TRI_aql_statement_list_s {
TRI_vector_pointer_t _statements;
struct TRI_aql_statement_list_t {
std::vector<struct TRI_aql_node_t*> _statements;
size_t _currentLevel;
}
TRI_aql_statement_list_t;
};
// -----------------------------------------------------------------------------
// --SECTION-- constructors / destructors
@ -81,7 +80,7 @@ void TRI_FreeStatementListAql (TRI_aql_statement_list_t* const);
/// @brief get the address of the dummy non-op node
////////////////////////////////////////////////////////////////////////////////
struct TRI_aql_node_s* TRI_GetDummyNopNodeAql (void);
struct TRI_aql_node_t* TRI_GetDummyNopNodeAql (void);
////////////////////////////////////////////////////////////////////////////////
/// @brief pull out subqueries in the statement list from the middle to the
@ -104,7 +103,7 @@ void TRI_CompactStatementListAql (TRI_aql_statement_list_t* const);
////////////////////////////////////////////////////////////////////////////////
bool TRI_InsertStatementListAql (TRI_aql_statement_list_t* const,
struct TRI_aql_node_s* const,
struct TRI_aql_node_t* const,
const size_t);
////////////////////////////////////////////////////////////////////////////////
@ -112,7 +111,7 @@ bool TRI_InsertStatementListAql (TRI_aql_statement_list_t* const,
////////////////////////////////////////////////////////////////////////////////
bool TRI_AppendStatementListAql (TRI_aql_statement_list_t* const,
struct TRI_aql_node_s* const);
struct TRI_aql_node_t* const);
#endif