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

some renaming

This commit is contained in:
Jan Steemann 2012-04-26 12:43:07 +02:00
parent 3a191bf8e9
commit 206919463c
16 changed files with 316 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
Ahuacatl/ahuacatl-ast-node.c
View File

@ -82,14 +82,14 @@
/// @{
////////////////////////////////////////////////////////////////////////////////
static inline void InitNode (TRI_aql_parse_context_t* const context,
static inline void InitNode (TRI_aql_context_t* const context,
TRI_aql_node_t* const node,
const TRI_aql_node_type_e type) {
node->_type = type;
node->_next = NULL;
TRI_InitVectorPointer(&node->_subNodes);
TRI_RegisterNodeParseContextAql(context, node);
TRI_RegisterNodeContextAql(context, node);
}
////////////////////////////////////////////////////////////////////////////////
@ -109,7 +109,7 @@ static inline void InitNode (TRI_aql_parse_context_t* const context,
/// @brief create an AST for node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeForAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeForAql (TRI_aql_context_t* const context,
const char* const name,
const TRI_aql_node_t* const expression) {
CREATE_NODE(AQL_NODE_FOR)
@ -136,7 +136,7 @@ TRI_aql_node_t* TRI_CreateNodeForAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST let node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeLetAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeLetAql (TRI_aql_context_t* const context,
const char* const name,
const TRI_aql_node_t* const expression) {
TRI_aql_node_let_t* node;
@ -172,7 +172,7 @@ TRI_aql_node_t* TRI_CreateNodeLetAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST filter node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeFilterAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeFilterAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const expression) {
CREATE_NODE(AQL_NODE_FILTER)
@ -185,7 +185,7 @@ TRI_aql_node_t* TRI_CreateNodeFilterAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST return node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeReturnAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeReturnAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const expression) {
CREATE_NODE(AQL_NODE_RETURN)
@ -198,7 +198,7 @@ TRI_aql_node_t* TRI_CreateNodeReturnAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST collect node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeCollectAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeCollectAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const list,
const char* const name) {
CREATE_NODE(AQL_NODE_COLLECT)
@ -216,7 +216,7 @@ TRI_aql_node_t* TRI_CreateNodeCollectAql (TRI_aql_parse_context_t* const context
/// @brief create an AST sort node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeSortAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeSortAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const list) {
CREATE_NODE(AQL_NODE_SORT)
@ -229,7 +229,7 @@ TRI_aql_node_t* TRI_CreateNodeSortAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST sort element node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeSortElementAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeSortElementAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const expression,
const bool ascending) {
CREATE_NODE(AQL_NODE_SORT_ELEMENT)
@ -244,7 +244,7 @@ TRI_aql_node_t* TRI_CreateNodeSortElementAql (TRI_aql_parse_context_t* const con
/// @brief create an AST limit node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeLimitAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeLimitAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const offset,
const TRI_aql_node_t* const count) {
CREATE_NODE(AQL_NODE_LIMIT)
@ -259,7 +259,7 @@ TRI_aql_node_t* TRI_CreateNodeLimitAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST assign node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeAssignAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeAssignAql (TRI_aql_context_t* const context,
const char* const name,
const TRI_aql_node_t* const expression) {
CREATE_NODE(AQL_NODE_ASSIGN)
@ -277,7 +277,7 @@ TRI_aql_node_t* TRI_CreateNodeAssignAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST variable node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeVariableAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeVariableAql (TRI_aql_context_t* const context,
const char* const name) {
CREATE_NODE(AQL_NODE_VARIABLE)
@ -285,7 +285,7 @@ TRI_aql_node_t* TRI_CreateNodeVariableAql (TRI_aql_parse_context_t* const contex
ABORT_OOM
}
if (!TRI_AddVariableParseContextAql(context, name)) {
if (!TRI_AddVariableContextAql(context, name)) {
// duplicate variable name
TRI_SetErrorAql(context, TRI_ERROR_QUERY_VARIABLE_REDECLARED, name);
return NULL;
@ -300,7 +300,7 @@ TRI_aql_node_t* TRI_CreateNodeVariableAql (TRI_aql_parse_context_t* const contex
/// @brief create an AST collection node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeCollectionAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeCollectionAql (TRI_aql_context_t* const context,
const char* const name) {
CREATE_NODE(AQL_NODE_COLLECTION)
@ -320,7 +320,7 @@ TRI_aql_node_t* TRI_CreateNodeCollectionAql (TRI_aql_parse_context_t* const cont
/// @brief create an AST reference node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeReferenceAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeReferenceAql (TRI_aql_context_t* const context,
const char* const name) {
CREATE_NODE(AQL_NODE_REFERENCE)
@ -337,7 +337,7 @@ TRI_aql_node_t* TRI_CreateNodeReferenceAql (TRI_aql_parse_context_t* const conte
/// @brief create an AST attribute node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeAttributeAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeAttributeAql (TRI_aql_context_t* const context,
const char* const name) {
CREATE_NODE(AQL_NODE_ATTRIBUTE)
@ -354,7 +354,7 @@ TRI_aql_node_t* TRI_CreateNodeAttributeAql (TRI_aql_parse_context_t* const conte
/// @brief create an AST parameter node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeParameterAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeParameterAql (TRI_aql_context_t* const context,
const char* const name) {
CREATE_NODE(AQL_NODE_PARAMETER)
@ -374,7 +374,7 @@ TRI_aql_node_t* TRI_CreateNodeParameterAql (TRI_aql_parse_context_t* const conte
/// @brief create an AST unary plus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryPlusAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryPlusAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const operand) {
CREATE_NODE(AQL_NODE_OPERATOR_UNARY_PLUS)
@ -387,7 +387,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorUnaryPlusAql (TRI_aql_parse_context_t* con
/// @brief create an AST unary minus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryMinusAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryMinusAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const operand) {
CREATE_NODE(AQL_NODE_OPERATOR_UNARY_MINUS)
@ -400,7 +400,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorUnaryMinusAql (TRI_aql_parse_context_t* co
/// @brief create an AST unary not node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryNotAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryNotAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const operand) {
CREATE_NODE(AQL_NODE_OPERATOR_UNARY_NOT)
@ -413,7 +413,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorUnaryNotAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary and node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryAndAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryAndAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_AND)
@ -428,7 +428,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryAndAql (TRI_aql_parse_context_t* con
/// @brief create an AST binary or node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryOrAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryOrAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_OR)
@ -443,7 +443,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryOrAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary eq node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryEqAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryEqAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_EQ)
@ -458,7 +458,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryEqAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary ne node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryNeAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryNeAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_NE)
@ -473,7 +473,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryNeAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary lt node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLtAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLtAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_LT)
@ -488,7 +488,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLtAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary le node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLeAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLeAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_LE)
@ -503,7 +503,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLeAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary gt node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGtAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGtAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_GT)
@ -518,7 +518,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGtAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary ge node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGeAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGeAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_GE)
@ -533,7 +533,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGeAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary in node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryInAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryInAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_IN)
@ -548,7 +548,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryInAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary plus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryPlusAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryPlusAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_PLUS)
@ -563,7 +563,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryPlusAql (TRI_aql_parse_context_t* co
/// @brief create an AST binary minus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryMinusAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryMinusAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_MINUS)
@ -578,7 +578,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryMinusAql (TRI_aql_parse_context_t* c
/// @brief create an AST binary times node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryTimesAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryTimesAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_TIMES)
@ -593,7 +593,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryTimesAql (TRI_aql_parse_context_t* c
/// @brief create an AST binary div node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryDivAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryDivAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_DIV)
@ -608,7 +608,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryDivAql (TRI_aql_parse_context_t* con
/// @brief create an AST binary mod node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryModAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryModAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const lhs,
const TRI_aql_node_t* const rhs) {
CREATE_NODE(AQL_NODE_OPERATOR_BINARY_MOD)
@ -623,7 +623,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryModAql (TRI_aql_parse_context_t* con
/// @brief create an AST ternary operator node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorTernaryAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeOperatorTernaryAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const condition,
const TRI_aql_node_t* const truePart,
const TRI_aql_node_t* const falsePart) {
@ -640,7 +640,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorTernaryAql (TRI_aql_parse_context_t* const
/// @brief create an AST subquery node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeSubqueryAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeSubqueryAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const query) {
CREATE_NODE(AQL_NODE_SUBQUERY)
@ -653,7 +653,7 @@ TRI_aql_node_t* TRI_CreateNodeSubqueryAql (TRI_aql_parse_context_t* const contex
/// @brief create an AST attribute access node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeAttributeAccessAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeAttributeAccessAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const accessed,
const char* const name) {
CREATE_NODE(AQL_NODE_ATTRIBUTE_ACCESS)
@ -672,7 +672,7 @@ TRI_aql_node_t* TRI_CreateNodeAttributeAccessAql (TRI_aql_parse_context_t* const
/// @brief create an AST index access node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeIndexedAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeIndexedAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const accessed,
const TRI_aql_node_t* const indexValue) {
CREATE_NODE(AQL_NODE_INDEXED)
@ -687,7 +687,7 @@ TRI_aql_node_t* TRI_CreateNodeIndexedAql (TRI_aql_parse_context_t* const context
/// @brief create an AST expand node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeExpandAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeExpandAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const expanded,
const TRI_aql_node_t* const expansion) {
CREATE_NODE(AQL_NODE_EXPAND)
@ -702,7 +702,7 @@ TRI_aql_node_t* TRI_CreateNodeExpandAql (TRI_aql_parse_context_t* const context,
/// @brief create an AST null value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueNullAql (TRI_aql_parse_context_t* const context) {
TRI_aql_node_t* TRI_CreateNodeValueNullAql (TRI_aql_context_t* const context) {
CREATE_NODE(AQL_NODE_VALUE)
TRI_AQL_NODE_TYPE(node) = AQL_TYPE_NULL;
@ -714,7 +714,7 @@ TRI_aql_node_t* TRI_CreateNodeValueNullAql (TRI_aql_parse_context_t* const conte
/// @brief create an AST int value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueIntAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeValueIntAql (TRI_aql_context_t* const context,
const int64_t value) {
CREATE_NODE(AQL_NODE_VALUE)
@ -728,7 +728,7 @@ TRI_aql_node_t* TRI_CreateNodeValueIntAql (TRI_aql_parse_context_t* const contex
/// @brief create an AST double value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueDoubleAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeValueDoubleAql (TRI_aql_context_t* const context,
const double value) {
CREATE_NODE(AQL_NODE_VALUE)
@ -742,7 +742,7 @@ TRI_aql_node_t* TRI_CreateNodeValueDoubleAql (TRI_aql_parse_context_t* const con
/// @brief create an AST bool value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueBoolAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeValueBoolAql (TRI_aql_context_t* const context,
const bool value) {
CREATE_NODE(AQL_NODE_VALUE)
@ -756,7 +756,7 @@ TRI_aql_node_t* TRI_CreateNodeValueBoolAql (TRI_aql_parse_context_t* const conte
/// @brief create an AST string value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueStringAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeValueStringAql (TRI_aql_context_t* const context,
const char* const value) {
CREATE_NODE(AQL_NODE_VALUE)
@ -774,7 +774,7 @@ TRI_aql_node_t* TRI_CreateNodeValueStringAql (TRI_aql_parse_context_t* const con
/// @brief create an AST list node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeListAql (TRI_aql_parse_context_t* const context) {
TRI_aql_node_t* TRI_CreateNodeListAql (TRI_aql_context_t* const context) {
CREATE_NODE(AQL_NODE_LIST)
return node;
@ -784,7 +784,7 @@ TRI_aql_node_t* TRI_CreateNodeListAql (TRI_aql_parse_context_t* const context) {
/// @brief create an AST array node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeArrayAql (TRI_aql_parse_context_t* const context) {
TRI_aql_node_t* TRI_CreateNodeArrayAql (TRI_aql_context_t* const context) {
CREATE_NODE(AQL_NODE_ARRAY)
return node;
@ -794,7 +794,7 @@ TRI_aql_node_t* TRI_CreateNodeArrayAql (TRI_aql_parse_context_t* const context)
/// @brief create an AST array element node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeArrayElementAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeArrayElementAql (TRI_aql_context_t* const context,
const char* const name,
const TRI_aql_node_t* const value) {
CREATE_NODE(AQL_NODE_ARRAY_ELEMENT)
@ -813,7 +813,7 @@ TRI_aql_node_t* TRI_CreateNodeArrayElementAql (TRI_aql_parse_context_t* const co
/// @brief create an AST function call node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeFcallAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_CreateNodeFcallAql (TRI_aql_context_t* const context,
const char* const name,
const TRI_aql_node_t* const parameters) {
CREATE_NODE(AQL_NODE_FCALL)
@ -857,7 +857,7 @@ TRI_aql_node_t* TRI_CreateNodeFcallAql (TRI_aql_parse_context_t* const context,
/// @brief add a value to the end of a list
////////////////////////////////////////////////////////////////////////////////
bool TRI_PushListAql (TRI_aql_parse_context_t* const context,
bool TRI_PushListAql (TRI_aql_context_t* const context,
const TRI_aql_node_t* const value) {
TRI_aql_node_t* node = TRI_PeekStackAql(context);
@ -872,7 +872,7 @@ bool TRI_PushListAql (TRI_aql_parse_context_t* const context,
/// @brief add a value to the end of an array
////////////////////////////////////////////////////////////////////////////////
bool TRI_PushArrayAql (TRI_aql_parse_context_t* const context,
bool TRI_PushArrayAql (TRI_aql_context_t* const context,
const char* const name,
const TRI_aql_node_t* const value) {
TRI_aql_node_t* node = TRI_PeekStackAql(context);

94
Ahuacatl/ahuacatl-ast-node.h
View File

@ -243,7 +243,7 @@ TRI_aql_node_t;
/// @brief create an AST for node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeForAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeForAql (TRI_aql_context_t* const,
const char* const,
const TRI_aql_node_t* const);
@ -251,7 +251,7 @@ TRI_aql_node_t* TRI_CreateNodeForAql (TRI_aql_parse_context_t* const,
/// @brief create an AST let node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeLetAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeLetAql (TRI_aql_context_t* const,
const char* const,
const TRI_aql_node_t* const);
@ -259,21 +259,21 @@ TRI_aql_node_t* TRI_CreateNodeLetAql (TRI_aql_parse_context_t* const,
/// @brief create an AST filter node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeFilterAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeFilterAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST return node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeReturnAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeReturnAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST collect node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeCollectAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeCollectAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const list,
const char* const);
@ -281,14 +281,14 @@ TRI_aql_node_t* TRI_CreateNodeCollectAql (TRI_aql_parse_context_t* const,
/// @brief create an AST sort node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeSortAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeSortAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST sort element node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeSortElementAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeSortElementAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const bool);
@ -296,7 +296,7 @@ TRI_aql_node_t* TRI_CreateNodeSortElementAql (TRI_aql_parse_context_t* const,
/// @brief create an AST limit node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeLimitAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeLimitAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -304,7 +304,7 @@ TRI_aql_node_t* TRI_CreateNodeLimitAql (TRI_aql_parse_context_t* const,
/// @brief create an AST assign node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeAssignAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeAssignAql (TRI_aql_context_t* const,
const char* const,
const TRI_aql_node_t* const);
@ -312,63 +312,63 @@ TRI_aql_node_t* TRI_CreateNodeAssignAql (TRI_aql_parse_context_t* const,
/// @brief create an AST parameter node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeParameterAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeParameterAql (TRI_aql_context_t* const,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST variable node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeVariableAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeVariableAql (TRI_aql_context_t* const,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST collection node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeCollectionAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeCollectionAql (TRI_aql_context_t* const,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST reference node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeReferenceAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeReferenceAql (TRI_aql_context_t* const,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST attribute node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeAttributeAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeAttributeAql (TRI_aql_context_t* const,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST unary plus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryPlusAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryPlusAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST unary minus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryMinusAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryMinusAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST unary not node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryNotAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorUnaryNotAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST binary and node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryAndAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryAndAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -376,7 +376,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryAndAql (TRI_aql_parse_context_t* con
/// @brief create an AST binary or node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryOrAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryOrAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -384,7 +384,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryOrAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary plus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryPlusAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryPlusAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -392,7 +392,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryPlusAql (TRI_aql_parse_context_t* co
/// @brief create an AST binary minus node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryMinusAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryMinusAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -400,7 +400,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryMinusAql (TRI_aql_parse_context_t* c
/// @brief create an AST binary times node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryTimesAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryTimesAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -408,7 +408,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryTimesAql (TRI_aql_parse_context_t* c
/// @brief create an AST binary div node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryDivAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryDivAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -416,7 +416,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryDivAql (TRI_aql_parse_context_t* con
/// @brief create an AST binary mod node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryModAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryModAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -424,7 +424,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryModAql (TRI_aql_parse_context_t* con
/// @brief create an AST binary eq node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryEqAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryEqAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -432,7 +432,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryEqAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary ne node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryNeAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryNeAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -440,7 +440,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryNeAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary lt node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLtAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLtAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -448,7 +448,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLtAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary le node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLeAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLeAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -456,7 +456,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryLeAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary gt node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGtAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGtAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -464,7 +464,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGtAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary ge node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGeAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGeAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -472,7 +472,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryGeAql (TRI_aql_parse_context_t* cons
/// @brief create an AST binary in node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryInAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorBinaryInAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -480,7 +480,7 @@ TRI_aql_node_t* TRI_CreateNodeOperatorBinaryInAql (TRI_aql_parse_context_t* cons
/// @brief create an AST ternary operator node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeOperatorTernaryAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeOperatorTernaryAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -489,14 +489,14 @@ TRI_aql_node_t* TRI_CreateNodeOperatorTernaryAql (TRI_aql_parse_context_t* const
/// @brief create an AST subquery node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeSubqueryAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeSubqueryAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST attribute node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeAttributeAccessAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeAttributeAccessAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const char* const);
@ -504,7 +504,7 @@ TRI_aql_node_t* TRI_CreateNodeAttributeAccessAql (TRI_aql_parse_context_t* const
/// @brief create an AST index access node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeIndexedAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeIndexedAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -512,7 +512,7 @@ TRI_aql_node_t* TRI_CreateNodeIndexedAql (TRI_aql_parse_context_t* const,
/// @brief create an AST expand node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeExpandAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeExpandAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const,
const TRI_aql_node_t* const);
@ -520,53 +520,53 @@ TRI_aql_node_t* TRI_CreateNodeExpandAql (TRI_aql_parse_context_t* const,
/// @brief create an AST null value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueNullAql (TRI_aql_parse_context_t* const);
TRI_aql_node_t* TRI_CreateNodeValueNullAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST int value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueIntAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeValueIntAql (TRI_aql_context_t* const,
const int64_t);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST double value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueDoubleAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeValueDoubleAql (TRI_aql_context_t* const,
const double);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST bool value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueBoolAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeValueBoolAql (TRI_aql_context_t* const,
const bool);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST string value node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeValueStringAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeValueStringAql (TRI_aql_context_t* const,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST list node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeListAql (TRI_aql_parse_context_t* const);
TRI_aql_node_t* TRI_CreateNodeListAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST array node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeArrayAql (TRI_aql_parse_context_t* const);
TRI_aql_node_t* TRI_CreateNodeArrayAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create an AST function call node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeFcallAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeFcallAql (TRI_aql_context_t* const,
const char* const,
const TRI_aql_node_t* const);
@ -574,7 +574,7 @@ TRI_aql_node_t* TRI_CreateNodeFcallAql (TRI_aql_parse_context_t* const,
/// @brief create an AST array element node
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_CreateNodeArrayElementAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_CreateNodeArrayElementAql (TRI_aql_context_t* const,
const char* const,
const TRI_aql_node_t* const);
@ -582,14 +582,14 @@ TRI_aql_node_t* TRI_CreateNodeArrayElementAql (TRI_aql_parse_context_t* const,
/// @brief add a value to the end of a list
////////////////////////////////////////////////////////////////////////////////
bool TRI_PushListAql (TRI_aql_parse_context_t* const,
bool TRI_PushListAql (TRI_aql_context_t* const,
const TRI_aql_node_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief add a value to the end of an array
////////////////////////////////////////////////////////////////////////////////
bool TRI_PushArrayAql (TRI_aql_parse_context_t* const,
bool TRI_PushArrayAql (TRI_aql_context_t* const,
const char* const,
const TRI_aql_node_t* const);

14
Ahuacatl/ahuacatl-bind-parameter.c
View File

@ -40,7 +40,7 @@
/// @brief create a value node from a bind parameter
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_node_t* CreateNodeFromJson (TRI_aql_parse_context_t* const context,
static TRI_aql_node_t* CreateNodeFromJson (TRI_aql_context_t* const context,
TRI_json_t* json) {
TRI_aql_node_t* node = NULL;
@ -148,7 +148,7 @@ static TRI_aql_node_t* ModifyNode (void* data,
TRI_aql_node_t* node) {
TRI_aql_bind_parameter_t* bind;
TRI_associative_pointer_t* bindValues;
TRI_aql_parse_context_t* context;
TRI_aql_context_t* context;
char* name;
if (!node || node->_type != AQL_NODE_PARAMETER) {
@ -156,7 +156,7 @@ static TRI_aql_node_t* ModifyNode (void* data,
}
// we found a parameter node
context = (TRI_aql_parse_context_t*) data;
context = (TRI_aql_context_t*) data;
assert(context);
bindValues = (TRI_associative_pointer_t*) &context->_parameterValues;
@ -245,7 +245,7 @@ bool TRI_EqualBindParameterAql (TRI_associative_pointer_t* array,
/// @brief free bind parameters
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeBindParametersAql (TRI_aql_parse_context_t* const context) {
void TRI_FreeBindParametersAql (TRI_aql_context_t* const context) {
size_t i;
size_t n;
@ -273,7 +273,7 @@ void TRI_FreeBindParametersAql (TRI_aql_parse_context_t* const context) {
/// @brief add bind parameters
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddParameterValuesAql (TRI_aql_parse_context_t* const context,
bool TRI_AddParameterValuesAql (TRI_aql_context_t* const context,
const TRI_json_t* const parameters) {
size_t i;
size_t n;
@ -322,7 +322,7 @@ bool TRI_AddParameterValuesAql (TRI_aql_parse_context_t* const context,
/// @brief validate bind parameters passed
////////////////////////////////////////////////////////////////////////////////
bool TRI_ValidateBindParametersAql (TRI_aql_parse_context_t* const context) {
bool TRI_ValidateBindParametersAql (TRI_aql_context_t* const context) {
size_t i;
size_t n;
@ -367,7 +367,7 @@ bool TRI_ValidateBindParametersAql (TRI_aql_parse_context_t* const context) {
/// @brief inject values of bind parameters into query
////////////////////////////////////////////////////////////////////////////////
bool TRI_InjectBindParametersAql (TRI_aql_parse_context_t* const context,
bool TRI_InjectBindParametersAql (TRI_aql_context_t* const context,
TRI_aql_node_t* node) {
TRI_aql_modify_tree_walker_t* walker;

8
Ahuacatl/ahuacatl-bind-parameter.h
View File

@ -93,26 +93,26 @@ bool TRI_EqualBindParameterAql (TRI_associative_pointer_t*,
/// @brief free bind parameters
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeBindParametersAql (TRI_aql_parse_context_t* const);
void TRI_FreeBindParametersAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief add bind parameters
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddParameterValuesAql (TRI_aql_parse_context_t* const,
bool TRI_AddParameterValuesAql (TRI_aql_context_t* const,
const TRI_json_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief validate bind parameters passed
////////////////////////////////////////////////////////////////////////////////
bool TRI_ValidateBindParametersAql (TRI_aql_parse_context_t* const);
bool TRI_ValidateBindParametersAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief inject values of bind parameters into query
////////////////////////////////////////////////////////////////////////////////
bool TRI_InjectBindParametersAql (TRI_aql_parse_context_t* const,
bool TRI_InjectBindParametersAql (TRI_aql_context_t* const,
TRI_aql_node_t* node);
////////////////////////////////////////////////////////////////////////////////

16
Ahuacatl/ahuacatl-collections.c
View File

@ -73,7 +73,7 @@ static TRI_aql_collection_t* CreateCollectionContainer (const char* const name)
/// @brief set up the collection names vector and order it
////////////////////////////////////////////////////////////////////////////////
bool SetupCollections (TRI_aql_parse_context_t* const context) {
bool SetupCollections (TRI_aql_context_t* const context) {
size_t i;
size_t n;
bool result = true;
@ -115,7 +115,7 @@ bool SetupCollections (TRI_aql_parse_context_t* const context) {
/// @brief open all collections used
////////////////////////////////////////////////////////////////////////////////
bool OpenCollections (TRI_aql_parse_context_t* const context) {
bool OpenCollections (TRI_aql_context_t* const context) {
size_t i;
size_t n;
@ -160,7 +160,7 @@ bool OpenCollections (TRI_aql_parse_context_t* const context) {
/// @brief unlock all collections used
////////////////////////////////////////////////////////////////////////////////
void TRI_UnlockCollectionsAql (TRI_aql_parse_context_t* const context) {
void TRI_UnlockCollectionsAql (TRI_aql_context_t* const context) {
size_t i;
// unlock in reverse order
@ -188,7 +188,7 @@ void TRI_UnlockCollectionsAql (TRI_aql_parse_context_t* const context) {
/// @brief lock all collections used
////////////////////////////////////////////////////////////////////////////////
bool TRI_LockCollectionsAql (TRI_aql_parse_context_t* const context) {
bool TRI_LockCollectionsAql (TRI_aql_context_t* const context) {
if (!SetupCollections(context)) {
return false;
}
@ -205,7 +205,7 @@ bool TRI_LockCollectionsAql (TRI_aql_parse_context_t* const context) {
/// @brief read-locks all collections used in a query
////////////////////////////////////////////////////////////////////////////////
bool TRI_ReadLockCollectionsAql (TRI_aql_parse_context_t* const context) {
bool TRI_ReadLockCollectionsAql (TRI_aql_context_t* const context) {
size_t i;
size_t n;
bool result = true;
@ -248,7 +248,7 @@ bool TRI_ReadLockCollectionsAql (TRI_aql_parse_context_t* const context) {
/// @brief read-unlocks all collections used in a query
////////////////////////////////////////////////////////////////////////////////
void TRI_ReadUnlockCollectionsAql (TRI_aql_parse_context_t* const context) {
void TRI_ReadUnlockCollectionsAql (TRI_aql_context_t* const context) {
size_t i;
// unlock in reverse order
@ -286,7 +286,7 @@ void TRI_ReadUnlockCollectionsAql (TRI_aql_parse_context_t* const context) {
/// @brief adds a gc marker for all collections used in a query
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddBarrierCollectionsAql (TRI_aql_parse_context_t* const context) {
bool TRI_AddBarrierCollectionsAql (TRI_aql_context_t* const context) {
size_t i;
size_t n;
bool result = true;
@ -329,7 +329,7 @@ bool TRI_AddBarrierCollectionsAql (TRI_aql_parse_context_t* const context) {
/// @brief removes the gc markers for all collections used in a query
////////////////////////////////////////////////////////////////////////////////
void TRI_RemoveBarrierCollectionsAql (TRI_aql_parse_context_t* const context) {
void TRI_RemoveBarrierCollectionsAql (TRI_aql_context_t* const context) {
size_t i;
// iterate in reverse order

12
Ahuacatl/ahuacatl-collections.h
View File

@ -79,37 +79,37 @@ TRI_aql_collection_t;
/// @brief unlock all collections used
////////////////////////////////////////////////////////////////////////////////
void TRI_UnlockCollectionsAql (TRI_aql_parse_context_t* const);
void TRI_UnlockCollectionsAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief lock all collections used
////////////////////////////////////////////////////////////////////////////////
bool TRI_LockCollectionsAql (TRI_aql_parse_context_t* const);
bool TRI_LockCollectionsAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief lock all collections used
////////////////////////////////////////////////////////////////////////////////
bool TRI_ReadLockCollectionsAql (TRI_aql_parse_context_t* const);
bool TRI_ReadLockCollectionsAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief read-unlocks all collections used in a query
////////////////////////////////////////////////////////////////////////////////
void TRI_ReadUnlockCollectionsAql (TRI_aql_parse_context_t* const);
void TRI_ReadUnlockCollectionsAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief adds a gc marker for all collections used in a query
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddBarrierCollectionsAql (TRI_aql_parse_context_t* const);
bool TRI_AddBarrierCollectionsAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief removes the gc markers for all collections used in a query
////////////////////////////////////////////////////////////////////////////////
void TRI_RemoveBarrierCollectionsAql (TRI_aql_parse_context_t* const);
void TRI_RemoveBarrierCollectionsAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @}

12
Ahuacatl/ahuacatl-constant-folder.c
View File

@ -40,7 +40,7 @@
/// @brief optimise an arithmetic operation with one operand
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_node_t* OptimiseUnaryArithmeticOperation (TRI_aql_parse_context_t* const context,
static TRI_aql_node_t* OptimiseUnaryArithmeticOperation (TRI_aql_context_t* const context,
TRI_aql_node_t* node) {
TRI_aql_node_t* operand = (TRI_aql_node_t*) node->_subNodes._buffer[0];
@ -77,7 +77,7 @@ static TRI_aql_node_t* OptimiseUnaryArithmeticOperation (TRI_aql_parse_context_t
/// @brief optimise a boolean operation with one operand
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_node_t* OptimiseUnaryLogicalOperation (TRI_aql_parse_context_t* const context,
static TRI_aql_node_t* OptimiseUnaryLogicalOperation (TRI_aql_context_t* const context,
TRI_aql_node_t* node) {
TRI_aql_node_t* operand = (TRI_aql_node_t*) node->_subNodes._buffer[0];
@ -108,7 +108,7 @@ static TRI_aql_node_t* OptimiseUnaryLogicalOperation (TRI_aql_parse_context_t* c
/// @brief optimise a boolean operation with two operands
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_node_t* OptimiseBinaryLogicalOperation (TRI_aql_parse_context_t* const context,
static TRI_aql_node_t* OptimiseBinaryLogicalOperation (TRI_aql_context_t* const context,
TRI_aql_node_t* node) {
TRI_aql_node_t* lhs = (TRI_aql_node_t*) node->_subNodes._buffer[0];
TRI_aql_node_t* rhs = (TRI_aql_node_t*) node->_subNodes._buffer[1];
@ -172,7 +172,7 @@ static TRI_aql_node_t* OptimiseBinaryLogicalOperation (TRI_aql_parse_context_t*
/// @brief optimise an arithmetic operation with two operands
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_node_t* OptimiseBinaryArithmeticOperation (TRI_aql_parse_context_t* const context,
static TRI_aql_node_t* OptimiseBinaryArithmeticOperation (TRI_aql_context_t* const context,
TRI_aql_node_t* node) {
TRI_aql_node_t* lhs = (TRI_aql_node_t*) node->_subNodes._buffer[0];
TRI_aql_node_t* rhs = (TRI_aql_node_t*) node->_subNodes._buffer[1];
@ -255,7 +255,7 @@ static TRI_aql_node_t* OptimiseBinaryArithmeticOperation (TRI_aql_parse_context_
////////////////////////////////////////////////////////////////////////////////
static TRI_aql_node_t* ModifyNode (void* data, TRI_aql_node_t* node) {
TRI_aql_parse_context_t* context = (TRI_aql_parse_context_t*) data;
TRI_aql_context_t* context = (TRI_aql_context_t*) data;
if (!node) {
return NULL;
@ -300,7 +300,7 @@ static TRI_aql_node_t* ModifyNode (void* data, TRI_aql_node_t* node) {
/// @brief fold constants recursively
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_FoldConstantsAql (TRI_aql_parse_context_t* const context,
TRI_aql_node_t* TRI_FoldConstantsAql (TRI_aql_context_t* const context,
TRI_aql_node_t* node) {
TRI_aql_modify_tree_walker_t* walker;

2
Ahuacatl/ahuacatl-constant-folder.h
View File

@ -54,7 +54,7 @@ extern "C" {
/// @brief fold constants recursively
////////////////////////////////////////////////////////////////////////////////
TRI_aql_node_t* TRI_FoldConstantsAql (TRI_aql_parse_context_t* const,
TRI_aql_node_t* TRI_FoldConstantsAql (TRI_aql_context_t* const,
TRI_aql_node_t*);
////////////////////////////////////////////////////////////////////////////////

258
Ahuacatl/ahuacatl-grammar.c
View File

@ -178,7 +178,7 @@ typedef union YYSTYPE
{
/* Line 214 of yacc.c */
#line 26 "Ahuacatl/ahuacatl-grammar.y"
#line 25 "Ahuacatl/ahuacatl-grammar.y"
TRI_aql_node_t* node;
char* strval;
@ -212,7 +212,7 @@ typedef struct YYLTYPE
/* Copy the second part of user declarations. */
/* Line 264 of yacc.c */
#line 33 "Ahuacatl/ahuacatl-grammar.y"
#line 32 "Ahuacatl/ahuacatl-grammar.y"
////////////////////////////////////////////////////////////////////////////////
@ -225,7 +225,7 @@ int Ahuacatllex (YYSTYPE*, YYLTYPE*, void*);
/// @brief register parse error
////////////////////////////////////////////////////////////////////////////////
void Ahuacatlerror (YYLTYPE* locp, TRI_aql_parse_context_t* const context, const char* err) {
void Ahuacatlerror (YYLTYPE* locp, TRI_aql_context_t* const context, const char* err) {
TRI_SetParseErrorAql(context, err, locp->first_line, locp->first_column);
}
@ -560,17 +560,17 @@ static const yytype_int8 yyrhs[] =
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
0, 173, 173, 173, 189, 191, 196, 199, 202, 205,
208, 211, 216, 227, 238, 238, 257, 257, 276, 278,
283, 293, 301, 304, 310, 310, 330, 335, 343, 354,
357, 360, 366, 374, 385, 397, 400, 408, 411, 414,
417, 417, 439, 442, 445, 451, 459, 467, 478, 486,
494, 502, 510, 518, 526, 534, 542, 550, 558, 566,
574, 582, 593, 604, 606, 611, 614, 620, 623, 629,
629, 642, 644, 649, 654, 662, 662, 675, 677, 682,
684, 689, 697, 714, 721, 728, 738, 745, 752, 762,
765, 771, 779, 793, 801, 809, 820, 831, 838, 847,
853, 860
0, 172, 172, 172, 188, 190, 195, 198, 201, 204,
207, 210, 215, 226, 237, 237, 256, 256, 275, 277,
282, 292, 300, 303, 309, 309, 329, 334, 342, 353,
356, 359, 365, 373, 384, 396, 399, 407, 410, 413,
416, 416, 438, 441, 444, 450, 458, 466, 477, 485,
493, 501, 509, 517, 525, 533, 541, 549, 557, 565,
573, 581, 592, 603, 605, 610, 613, 619, 622, 628,
628, 641, 643, 648, 653, 661, 661, 674, 676, 681,
683, 688, 696, 713, 720, 727, 737, 744, 751, 761,
764, 770, 778, 792, 800, 808, 819, 830, 837, 846,
852, 859
};
#endif
@ -955,7 +955,7 @@ do { \
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TRI_aql_parse_context_t* const context)
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TRI_aql_context_t* const context)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context)
@ -963,7 +963,7 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context)
int yytype;
YYSTYPE const * const yyvaluep;
YYLTYPE const * const yylocationp;
TRI_aql_parse_context_t* const context;
TRI_aql_context_t* const context;
#endif
{
if (!yyvaluep)
@ -991,7 +991,7 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, context)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TRI_aql_parse_context_t* const context)
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, TRI_aql_context_t* const context)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, context)
@ -999,7 +999,7 @@ yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, context)
int yytype;
YYSTYPE const * const yyvaluep;
YYLTYPE const * const yylocationp;
TRI_aql_parse_context_t* const context;
TRI_aql_context_t* const context;
#endif
{
if (yytype < YYNTOKENS)
@ -1052,14 +1052,14 @@ do { \
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, TRI_aql_parse_context_t* const context)
yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, TRI_aql_context_t* const context)
#else
static void
yy_reduce_print (yyvsp, yylsp, yyrule, context)
YYSTYPE *yyvsp;
YYLTYPE *yylsp;
int yyrule;
TRI_aql_parse_context_t* const context;
TRI_aql_context_t* const context;
#endif
{
int yynrhs = yyr2[yyrule];
@ -1332,7 +1332,7 @@ yysyntax_error (char *yyresult, int yystate, int yychar)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, TRI_aql_parse_context_t* const context)
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, TRI_aql_context_t* const context)
#else
static void
yydestruct (yymsg, yytype, yyvaluep, yylocationp, context)
@ -1340,7 +1340,7 @@ yydestruct (yymsg, yytype, yyvaluep, yylocationp, context)
int yytype;
YYSTYPE *yyvaluep;
YYLTYPE *yylocationp;
TRI_aql_parse_context_t* const context;
TRI_aql_context_t* const context;
#endif
{
YYUSE (yyvaluep);
@ -1368,7 +1368,7 @@ int yyparse ();
#endif
#else /* ! YYPARSE_PARAM */
#if defined __STDC__ || defined __cplusplus
int yyparse (TRI_aql_parse_context_t* const context);
int yyparse (TRI_aql_context_t* const context);
#else
int yyparse ();
#endif
@ -1396,11 +1396,11 @@ yyparse (YYPARSE_PARAM)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (TRI_aql_parse_context_t* const context)
yyparse (TRI_aql_context_t* const context)
#else
int
yyparse (context)
TRI_aql_parse_context_t* const context;
TRI_aql_context_t* const context;
#endif
#endif
{
@ -1682,10 +1682,10 @@ yyreduce:
case 2:
/* Line 1455 of yacc.c */
#line 173 "Ahuacatl/ahuacatl-grammar.y"
#line 172 "Ahuacatl/ahuacatl-grammar.y"
{
// a query or a sub-query always starts a new scope
if (!TRI_StartScopeParseContextAql(context)) {
if (!TRI_StartScopeContextAql(context)) {
YYABORT;
}
;}
@ -1694,21 +1694,21 @@ yyreduce:
case 3:
/* Line 1455 of yacc.c */
#line 178 "Ahuacatl/ahuacatl-grammar.y"
#line 177 "Ahuacatl/ahuacatl-grammar.y"
{
// end the scope
TRI_AddStatementAql(context, (yyvsp[(3) - (3)].node));
(yyval.node) = (TRI_aql_node_t*) TRI_GetFirstStatementAql(context);
TRI_EndScopeParseContextAql(context);
TRI_EndScopeContextAql(context);
;}
break;
case 4:
/* Line 1455 of yacc.c */
#line 189 "Ahuacatl/ahuacatl-grammar.y"
#line 188 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -1716,7 +1716,7 @@ yyreduce:
case 5:
/* Line 1455 of yacc.c */
#line 191 "Ahuacatl/ahuacatl-grammar.y"
#line 190 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -1724,7 +1724,7 @@ yyreduce:
case 6:
/* Line 1455 of yacc.c */
#line 196 "Ahuacatl/ahuacatl-grammar.y"
#line 195 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_AddStatementAql(context, (yyvsp[(1) - (1)].node));
;}
@ -1733,7 +1733,7 @@ yyreduce:
case 7:
/* Line 1455 of yacc.c */
#line 199 "Ahuacatl/ahuacatl-grammar.y"
#line 198 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_AddStatementAql(context, (yyvsp[(1) - (1)].node));
;}
@ -1742,7 +1742,7 @@ yyreduce:
case 8:
/* Line 1455 of yacc.c */
#line 202 "Ahuacatl/ahuacatl-grammar.y"
#line 201 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_AddStatementAql(context, (yyvsp[(1) - (1)].node));
;}
@ -1751,7 +1751,7 @@ yyreduce:
case 9:
/* Line 1455 of yacc.c */
#line 205 "Ahuacatl/ahuacatl-grammar.y"
#line 204 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_AddStatementAql(context, (yyvsp[(1) - (1)].node));
;}
@ -1760,7 +1760,7 @@ yyreduce:
case 10:
/* Line 1455 of yacc.c */
#line 208 "Ahuacatl/ahuacatl-grammar.y"
#line 207 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_AddStatementAql(context, (yyvsp[(1) - (1)].node));
;}
@ -1769,7 +1769,7 @@ yyreduce:
case 11:
/* Line 1455 of yacc.c */
#line 211 "Ahuacatl/ahuacatl-grammar.y"
#line 210 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_AddStatementAql(context, (yyvsp[(1) - (1)].node));
;}
@ -1778,7 +1778,7 @@ yyreduce:
case 12:
/* Line 1455 of yacc.c */
#line 216 "Ahuacatl/ahuacatl-grammar.y"
#line 215 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeForAql(context, (yyvsp[(2) - (4)].strval), (yyvsp[(4) - (4)].node));
if (!node) {
@ -1792,7 +1792,7 @@ yyreduce:
case 13:
/* Line 1455 of yacc.c */
#line 227 "Ahuacatl/ahuacatl-grammar.y"
#line 226 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeFilterAql(context, (yyvsp[(2) - (2)].node));
if (!node) {
@ -1806,9 +1806,9 @@ yyreduce:
case 14:
/* Line 1455 of yacc.c */
#line 238 "Ahuacatl/ahuacatl-grammar.y"
#line 237 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushStackAql(context, (yyvsp[(2) - (2)].strval)) || !TRI_StartScopeParseContextAql(context)) {
if (!TRI_PushStackAql(context, (yyvsp[(2) - (2)].strval)) || !TRI_StartScopeContextAql(context)) {
YYABORT;
}
;}
@ -1817,11 +1817,11 @@ yyreduce:
case 15:
/* Line 1455 of yacc.c */
#line 242 "Ahuacatl/ahuacatl-grammar.y"
#line 241 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node;
TRI_EndScopeParseContextAql(context);
TRI_EndScopeContextAql(context);
node = TRI_CreateNodeAssignAql(context, TRI_PopStackAql(context), (yyvsp[(6) - (7)].node));
if (!node) {
@ -1835,7 +1835,7 @@ yyreduce:
case 16:
/* Line 1455 of yacc.c */
#line 257 "Ahuacatl/ahuacatl-grammar.y"
#line 256 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeListAql(context);
@ -1850,7 +1850,7 @@ yyreduce:
case 17:
/* Line 1455 of yacc.c */
#line 265 "Ahuacatl/ahuacatl-grammar.y"
#line 264 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeCollectAql(context, TRI_PopStackAql(context), (yyvsp[(4) - (4)].strval));
if (!node) {
@ -1864,7 +1864,7 @@ yyreduce:
case 18:
/* Line 1455 of yacc.c */
#line 276 "Ahuacatl/ahuacatl-grammar.y"
#line 275 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -1872,7 +1872,7 @@ yyreduce:
case 19:
/* Line 1455 of yacc.c */
#line 278 "Ahuacatl/ahuacatl-grammar.y"
#line 277 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -1880,7 +1880,7 @@ yyreduce:
case 20:
/* Line 1455 of yacc.c */
#line 283 "Ahuacatl/ahuacatl-grammar.y"
#line 282 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeAssignAql(context, (yyvsp[(1) - (3)].strval), (yyvsp[(3) - (3)].node));
if (!node) {
@ -1896,7 +1896,7 @@ yyreduce:
case 21:
/* Line 1455 of yacc.c */
#line 293 "Ahuacatl/ahuacatl-grammar.y"
#line 292 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushListAql(context, (yyvsp[(1) - (1)].node))) {
YYABORT;
@ -1907,7 +1907,7 @@ yyreduce:
case 22:
/* Line 1455 of yacc.c */
#line 301 "Ahuacatl/ahuacatl-grammar.y"
#line 300 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.strval) = NULL;
;}
@ -1916,7 +1916,7 @@ yyreduce:
case 23:
/* Line 1455 of yacc.c */
#line 304 "Ahuacatl/ahuacatl-grammar.y"
#line 303 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.strval) = (yyvsp[(2) - (2)].strval);
;}
@ -1925,7 +1925,7 @@ yyreduce:
case 24:
/* Line 1455 of yacc.c */
#line 310 "Ahuacatl/ahuacatl-grammar.y"
#line 309 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeListAql(context);
@ -1940,7 +1940,7 @@ yyreduce:
case 25:
/* Line 1455 of yacc.c */
#line 318 "Ahuacatl/ahuacatl-grammar.y"
#line 317 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* list = TRI_PopStackAql(context);
TRI_aql_node_t* node = TRI_CreateNodeSortAql(context, list);
@ -1955,7 +1955,7 @@ yyreduce:
case 26:
/* Line 1455 of yacc.c */
#line 330 "Ahuacatl/ahuacatl-grammar.y"
#line 329 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushListAql(context, (yyvsp[(1) - (1)].node))) {
YYABORT;
@ -1966,7 +1966,7 @@ yyreduce:
case 27:
/* Line 1455 of yacc.c */
#line 335 "Ahuacatl/ahuacatl-grammar.y"
#line 334 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushListAql(context, (yyvsp[(3) - (3)].node))) {
YYABORT;
@ -1977,7 +1977,7 @@ yyreduce:
case 28:
/* Line 1455 of yacc.c */
#line 343 "Ahuacatl/ahuacatl-grammar.y"
#line 342 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeSortElementAql(context, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].boolval));
if (!node) {
@ -1991,7 +1991,7 @@ yyreduce:
case 29:
/* Line 1455 of yacc.c */
#line 354 "Ahuacatl/ahuacatl-grammar.y"
#line 353 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.boolval) = true;
;}
@ -2000,7 +2000,7 @@ yyreduce:
case 30:
/* Line 1455 of yacc.c */
#line 357 "Ahuacatl/ahuacatl-grammar.y"
#line 356 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.boolval) = true;
;}
@ -2009,7 +2009,7 @@ yyreduce:
case 31:
/* Line 1455 of yacc.c */
#line 360 "Ahuacatl/ahuacatl-grammar.y"
#line 359 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.boolval) = false;
;}
@ -2018,7 +2018,7 @@ yyreduce:
case 32:
/* Line 1455 of yacc.c */
#line 366 "Ahuacatl/ahuacatl-grammar.y"
#line 365 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeLimitAql(context, TRI_CreateNodeValueIntAql(context, 0), TRI_CreateNodeValueIntAql(context, (yyvsp[(2) - (2)].intval)));
if (!node) {
@ -2032,7 +2032,7 @@ yyreduce:
case 33:
/* Line 1455 of yacc.c */
#line 374 "Ahuacatl/ahuacatl-grammar.y"
#line 373 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeLimitAql(context, TRI_CreateNodeValueIntAql(context, (yyvsp[(2) - (4)].intval)), TRI_CreateNodeValueIntAql(context, (yyvsp[(4) - (4)].intval)));
if (!node) {
@ -2046,7 +2046,7 @@ yyreduce:
case 34:
/* Line 1455 of yacc.c */
#line 385 "Ahuacatl/ahuacatl-grammar.y"
#line 384 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeReturnAql(context, (yyvsp[(2) - (2)].node));
if (!node) {
@ -2060,7 +2060,7 @@ yyreduce:
case 35:
/* Line 1455 of yacc.c */
#line 397 "Ahuacatl/ahuacatl-grammar.y"
#line 396 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(2) - (3)].node);
;}
@ -2069,7 +2069,7 @@ yyreduce:
case 36:
/* Line 1455 of yacc.c */
#line 400 "Ahuacatl/ahuacatl-grammar.y"
#line 399 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeSubqueryAql(context, (yyvsp[(2) - (3)].node));
if (!node) {
@ -2083,7 +2083,7 @@ yyreduce:
case 37:
/* Line 1455 of yacc.c */
#line 408 "Ahuacatl/ahuacatl-grammar.y"
#line 407 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2092,7 +2092,7 @@ yyreduce:
case 38:
/* Line 1455 of yacc.c */
#line 411 "Ahuacatl/ahuacatl-grammar.y"
#line 410 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2101,7 +2101,7 @@ yyreduce:
case 39:
/* Line 1455 of yacc.c */
#line 414 "Ahuacatl/ahuacatl-grammar.y"
#line 413 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2110,7 +2110,7 @@ yyreduce:
case 40:
/* Line 1455 of yacc.c */
#line 417 "Ahuacatl/ahuacatl-grammar.y"
#line 416 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node;
@ -2130,7 +2130,7 @@ yyreduce:
case 41:
/* Line 1455 of yacc.c */
#line 430 "Ahuacatl/ahuacatl-grammar.y"
#line 429 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* list = TRI_PopStackAql(context);
TRI_aql_node_t* node = TRI_CreateNodeFcallAql(context, TRI_PopStackAql(context), list);
@ -2145,7 +2145,7 @@ yyreduce:
case 42:
/* Line 1455 of yacc.c */
#line 439 "Ahuacatl/ahuacatl-grammar.y"
#line 438 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2154,7 +2154,7 @@ yyreduce:
case 43:
/* Line 1455 of yacc.c */
#line 442 "Ahuacatl/ahuacatl-grammar.y"
#line 441 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2163,7 +2163,7 @@ yyreduce:
case 44:
/* Line 1455 of yacc.c */
#line 445 "Ahuacatl/ahuacatl-grammar.y"
#line 444 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2172,7 +2172,7 @@ yyreduce:
case 45:
/* Line 1455 of yacc.c */
#line 451 "Ahuacatl/ahuacatl-grammar.y"
#line 450 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorUnaryPlusAql(context, (yyvsp[(2) - (2)].node));
if (!node) {
@ -2186,7 +2186,7 @@ yyreduce:
case 46:
/* Line 1455 of yacc.c */
#line 459 "Ahuacatl/ahuacatl-grammar.y"
#line 458 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorUnaryMinusAql(context, (yyvsp[(2) - (2)].node));
if (!node) {
@ -2200,7 +2200,7 @@ yyreduce:
case 47:
/* Line 1455 of yacc.c */
#line 467 "Ahuacatl/ahuacatl-grammar.y"
#line 466 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorUnaryNotAql(context, (yyvsp[(2) - (2)].node));
if (!node) {
@ -2214,7 +2214,7 @@ yyreduce:
case 48:
/* Line 1455 of yacc.c */
#line 478 "Ahuacatl/ahuacatl-grammar.y"
#line 477 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryOrAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2228,7 +2228,7 @@ yyreduce:
case 49:
/* Line 1455 of yacc.c */
#line 486 "Ahuacatl/ahuacatl-grammar.y"
#line 485 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryAndAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2242,7 +2242,7 @@ yyreduce:
case 50:
/* Line 1455 of yacc.c */
#line 494 "Ahuacatl/ahuacatl-grammar.y"
#line 493 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryPlusAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2256,7 +2256,7 @@ yyreduce:
case 51:
/* Line 1455 of yacc.c */
#line 502 "Ahuacatl/ahuacatl-grammar.y"
#line 501 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryMinusAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2270,7 +2270,7 @@ yyreduce:
case 52:
/* Line 1455 of yacc.c */
#line 510 "Ahuacatl/ahuacatl-grammar.y"
#line 509 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryTimesAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2284,7 +2284,7 @@ yyreduce:
case 53:
/* Line 1455 of yacc.c */
#line 518 "Ahuacatl/ahuacatl-grammar.y"
#line 517 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryDivAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2298,7 +2298,7 @@ yyreduce:
case 54:
/* Line 1455 of yacc.c */
#line 526 "Ahuacatl/ahuacatl-grammar.y"
#line 525 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryModAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2312,7 +2312,7 @@ yyreduce:
case 55:
/* Line 1455 of yacc.c */
#line 534 "Ahuacatl/ahuacatl-grammar.y"
#line 533 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryEqAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2326,7 +2326,7 @@ yyreduce:
case 56:
/* Line 1455 of yacc.c */
#line 542 "Ahuacatl/ahuacatl-grammar.y"
#line 541 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryNeAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2340,7 +2340,7 @@ yyreduce:
case 57:
/* Line 1455 of yacc.c */
#line 550 "Ahuacatl/ahuacatl-grammar.y"
#line 549 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryLtAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2354,7 +2354,7 @@ yyreduce:
case 58:
/* Line 1455 of yacc.c */
#line 558 "Ahuacatl/ahuacatl-grammar.y"
#line 557 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryGtAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2368,7 +2368,7 @@ yyreduce:
case 59:
/* Line 1455 of yacc.c */
#line 566 "Ahuacatl/ahuacatl-grammar.y"
#line 565 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryLeAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2382,7 +2382,7 @@ yyreduce:
case 60:
/* Line 1455 of yacc.c */
#line 574 "Ahuacatl/ahuacatl-grammar.y"
#line 573 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryGeAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2396,7 +2396,7 @@ yyreduce:
case 61:
/* Line 1455 of yacc.c */
#line 582 "Ahuacatl/ahuacatl-grammar.y"
#line 581 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorBinaryInAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
if (!node) {
@ -2410,7 +2410,7 @@ yyreduce:
case 62:
/* Line 1455 of yacc.c */
#line 593 "Ahuacatl/ahuacatl-grammar.y"
#line 592 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeOperatorTernaryAql(context, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
if (!node) {
@ -2424,7 +2424,7 @@ yyreduce:
case 63:
/* Line 1455 of yacc.c */
#line 604 "Ahuacatl/ahuacatl-grammar.y"
#line 603 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2432,7 +2432,7 @@ yyreduce:
case 64:
/* Line 1455 of yacc.c */
#line 606 "Ahuacatl/ahuacatl-grammar.y"
#line 605 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2440,7 +2440,7 @@ yyreduce:
case 65:
/* Line 1455 of yacc.c */
#line 611 "Ahuacatl/ahuacatl-grammar.y"
#line 610 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_PushListAql(context, (yyvsp[(1) - (1)].node));
;}
@ -2449,7 +2449,7 @@ yyreduce:
case 66:
/* Line 1455 of yacc.c */
#line 614 "Ahuacatl/ahuacatl-grammar.y"
#line 613 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_PushListAql(context, (yyvsp[(3) - (3)].node));
;}
@ -2458,7 +2458,7 @@ yyreduce:
case 67:
/* Line 1455 of yacc.c */
#line 620 "Ahuacatl/ahuacatl-grammar.y"
#line 619 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2467,7 +2467,7 @@ yyreduce:
case 68:
/* Line 1455 of yacc.c */
#line 623 "Ahuacatl/ahuacatl-grammar.y"
#line 622 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2476,7 +2476,7 @@ yyreduce:
case 69:
/* Line 1455 of yacc.c */
#line 629 "Ahuacatl/ahuacatl-grammar.y"
#line 628 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeListAql(context);
if (!node) {
@ -2490,7 +2490,7 @@ yyreduce:
case 70:
/* Line 1455 of yacc.c */
#line 636 "Ahuacatl/ahuacatl-grammar.y"
#line 635 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = TRI_PopStackAql(context);
;}
@ -2499,7 +2499,7 @@ yyreduce:
case 71:
/* Line 1455 of yacc.c */
#line 642 "Ahuacatl/ahuacatl-grammar.y"
#line 641 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2507,7 +2507,7 @@ yyreduce:
case 72:
/* Line 1455 of yacc.c */
#line 644 "Ahuacatl/ahuacatl-grammar.y"
#line 643 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2515,7 +2515,7 @@ yyreduce:
case 73:
/* Line 1455 of yacc.c */
#line 649 "Ahuacatl/ahuacatl-grammar.y"
#line 648 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushListAql(context, (yyvsp[(1) - (1)].node))) {
YYABORT;
@ -2526,7 +2526,7 @@ yyreduce:
case 74:
/* Line 1455 of yacc.c */
#line 654 "Ahuacatl/ahuacatl-grammar.y"
#line 653 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushListAql(context, (yyvsp[(3) - (3)].node))) {
YYABORT;
@ -2537,7 +2537,7 @@ yyreduce:
case 75:
/* Line 1455 of yacc.c */
#line 662 "Ahuacatl/ahuacatl-grammar.y"
#line 661 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeArrayAql(context);
if (!node) {
@ -2551,7 +2551,7 @@ yyreduce:
case 76:
/* Line 1455 of yacc.c */
#line 669 "Ahuacatl/ahuacatl-grammar.y"
#line 668 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = TRI_PopStackAql(context);
;}
@ -2560,7 +2560,7 @@ yyreduce:
case 77:
/* Line 1455 of yacc.c */
#line 675 "Ahuacatl/ahuacatl-grammar.y"
#line 674 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2568,7 +2568,7 @@ yyreduce:
case 78:
/* Line 1455 of yacc.c */
#line 677 "Ahuacatl/ahuacatl-grammar.y"
#line 676 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2576,7 +2576,7 @@ yyreduce:
case 79:
/* Line 1455 of yacc.c */
#line 682 "Ahuacatl/ahuacatl-grammar.y"
#line 681 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2584,7 +2584,7 @@ yyreduce:
case 80:
/* Line 1455 of yacc.c */
#line 684 "Ahuacatl/ahuacatl-grammar.y"
#line 683 "Ahuacatl/ahuacatl-grammar.y"
{
;}
break;
@ -2592,7 +2592,7 @@ yyreduce:
case 81:
/* Line 1455 of yacc.c */
#line 689 "Ahuacatl/ahuacatl-grammar.y"
#line 688 "Ahuacatl/ahuacatl-grammar.y"
{
if (!TRI_PushArrayAql(context, (yyvsp[(1) - (3)].strval), (yyvsp[(3) - (3)].node))) {
YYABORT;
@ -2603,7 +2603,7 @@ yyreduce:
case 82:
/* Line 1455 of yacc.c */
#line 697 "Ahuacatl/ahuacatl-grammar.y"
#line 696 "Ahuacatl/ahuacatl-grammar.y"
{
// variable or collection
TRI_aql_node_t* node;
@ -2626,7 +2626,7 @@ yyreduce:
case 83:
/* Line 1455 of yacc.c */
#line 714 "Ahuacatl/ahuacatl-grammar.y"
#line 713 "Ahuacatl/ahuacatl-grammar.y"
{
// variable[]
(yyval.node) = TRI_CreateNodeIndexedAql(context, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
@ -2639,7 +2639,7 @@ yyreduce:
case 84:
/* Line 1455 of yacc.c */
#line 721 "Ahuacatl/ahuacatl-grammar.y"
#line 720 "Ahuacatl/ahuacatl-grammar.y"
{
// variable[*]
(yyval.node) = TRI_CreateNodeExpandAql(context, (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node));
@ -2652,7 +2652,7 @@ yyreduce:
case 85:
/* Line 1455 of yacc.c */
#line 728 "Ahuacatl/ahuacatl-grammar.y"
#line 727 "Ahuacatl/ahuacatl-grammar.y"
{
// variable.reference
(yyval.node) = TRI_CreateNodeAttributeAccessAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].strval));
@ -2665,7 +2665,7 @@ yyreduce:
case 86:
/* Line 1455 of yacc.c */
#line 738 "Ahuacatl/ahuacatl-grammar.y"
#line 737 "Ahuacatl/ahuacatl-grammar.y"
{
// reference
(yyval.node) = TRI_CreateNodeAttributeAql(context, (yyvsp[(1) - (1)].strval));
@ -2678,7 +2678,7 @@ yyreduce:
case 87:
/* Line 1455 of yacc.c */
#line 745 "Ahuacatl/ahuacatl-grammar.y"
#line 744 "Ahuacatl/ahuacatl-grammar.y"
{
// variable[]
(yyval.node) = TRI_CreateNodeIndexedAql(context, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
@ -2691,7 +2691,7 @@ yyreduce:
case 88:
/* Line 1455 of yacc.c */
#line 752 "Ahuacatl/ahuacatl-grammar.y"
#line 751 "Ahuacatl/ahuacatl-grammar.y"
{
// variable.variable
(yyval.node) = TRI_CreateNodeAttributeAccessAql(context, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].strval));
@ -2704,7 +2704,7 @@ yyreduce:
case 89:
/* Line 1455 of yacc.c */
#line 762 "Ahuacatl/ahuacatl-grammar.y"
#line 761 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2713,7 +2713,7 @@ yyreduce:
case 90:
/* Line 1455 of yacc.c */
#line 765 "Ahuacatl/ahuacatl-grammar.y"
#line 764 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.node) = (yyvsp[(1) - (1)].node);
;}
@ -2722,7 +2722,7 @@ yyreduce:
case 91:
/* Line 1455 of yacc.c */
#line 771 "Ahuacatl/ahuacatl-grammar.y"
#line 770 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeValueStringAql(context, (yyvsp[(1) - (1)].strval));
if (!node) {
@ -2736,7 +2736,7 @@ yyreduce:
case 92:
/* Line 1455 of yacc.c */
#line 779 "Ahuacatl/ahuacatl-grammar.y"
#line 778 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node;
@ -2756,7 +2756,7 @@ yyreduce:
case 93:
/* Line 1455 of yacc.c */
#line 793 "Ahuacatl/ahuacatl-grammar.y"
#line 792 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeValueNullAql(context);
if (!node) {
@ -2770,7 +2770,7 @@ yyreduce:
case 94:
/* Line 1455 of yacc.c */
#line 801 "Ahuacatl/ahuacatl-grammar.y"
#line 800 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeValueBoolAql(context, true);
if (!node) {
@ -2784,7 +2784,7 @@ yyreduce:
case 95:
/* Line 1455 of yacc.c */
#line 809 "Ahuacatl/ahuacatl-grammar.y"
#line 808 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeValueBoolAql(context, false);
if (!node) {
@ -2798,7 +2798,7 @@ yyreduce:
case 96:
/* Line 1455 of yacc.c */
#line 820 "Ahuacatl/ahuacatl-grammar.y"
#line 819 "Ahuacatl/ahuacatl-grammar.y"
{
TRI_aql_node_t* node = TRI_CreateNodeParameterAql(context, (yyvsp[(1) - (1)].strval));
if (!node) {
@ -2812,7 +2812,7 @@ yyreduce:
case 97:
/* Line 1455 of yacc.c */
#line 831 "Ahuacatl/ahuacatl-grammar.y"
#line 830 "Ahuacatl/ahuacatl-grammar.y"
{
if (!(yyvsp[(1) - (1)].strval)) {
YYABORT;
@ -2825,7 +2825,7 @@ yyreduce:
case 98:
/* Line 1455 of yacc.c */
#line 838 "Ahuacatl/ahuacatl-grammar.y"
#line 837 "Ahuacatl/ahuacatl-grammar.y"
{
if (!(yyvsp[(1) - (1)].strval)) {
YYABORT;
@ -2838,7 +2838,7 @@ yyreduce:
case 99:
/* Line 1455 of yacc.c */
#line 847 "Ahuacatl/ahuacatl-grammar.y"
#line 846 "Ahuacatl/ahuacatl-grammar.y"
{
(yyval.strval) = (yyvsp[(1) - (1)].strval);
;}
@ -2847,7 +2847,7 @@ yyreduce:
case 100:
/* Line 1455 of yacc.c */
#line 853 "Ahuacatl/ahuacatl-grammar.y"
#line 852 "Ahuacatl/ahuacatl-grammar.y"
{
if (!(yyvsp[(1) - (1)].strval)) {
YYABORT;
@ -2860,7 +2860,7 @@ yyreduce:
case 101:
/* Line 1455 of yacc.c */
#line 860 "Ahuacatl/ahuacatl-grammar.y"
#line 859 "Ahuacatl/ahuacatl-grammar.y"
{
if (!(yyvsp[(2) - (2)].strval)) {
YYABORT;

2
Ahuacatl/ahuacatl-grammar.h
View File

@ -97,7 +97,7 @@ typedef union YYSTYPE
{
/* Line 1676 of yacc.c */
#line 26 "Ahuacatl/ahuacatl-grammar.y"
#line 25 "Ahuacatl/ahuacatl-grammar.y"
TRI_aql_node_t* node;
char* strval;

13
Ahuacatl/ahuacatl-grammar.y
View File

@ -3,7 +3,7 @@
%name-prefix="Ahuacatl"
%locations
%defines
%parse-param { TRI_aql_parse_context_t* const context }
%parse-param { TRI_aql_context_t* const context }
%lex-param { void* scanner }
%error-verbose
@ -22,7 +22,6 @@
%}
%union {
TRI_aql_node_t* node;
char* strval;
@ -42,7 +41,7 @@ int Ahuacatllex (YYSTYPE*, YYLTYPE*, void*);
/// @brief register parse error
////////////////////////////////////////////////////////////////////////////////
void Ahuacatlerror (YYLTYPE* locp, TRI_aql_parse_context_t* const context, const char* err) {
void Ahuacatlerror (YYLTYPE* locp, TRI_aql_context_t* const context, const char* err) {
TRI_SetParseErrorAql(context, err, locp->first_line, locp->first_column);
}
@ -172,7 +171,7 @@ void Ahuacatlerror (YYLTYPE* locp, TRI_aql_parse_context_t* const context, const
query:
{
// a query or a sub-query always starts a new scope
if (!TRI_StartScopeParseContextAql(context)) {
if (!TRI_StartScopeContextAql(context)) {
YYABORT;
}
} optional_statement_block_statements return_statement {
@ -181,7 +180,7 @@ query:
$$ = (TRI_aql_node_t*) TRI_GetFirstStatementAql(context);
TRI_EndScopeParseContextAql(context);
TRI_EndScopeContextAql(context);
}
;
@ -236,13 +235,13 @@ filter_statement:
let_statement:
T_LET variable_name {
if (!TRI_PushStackAql(context, $2) || !TRI_StartScopeParseContextAql(context)) {
if (!TRI_PushStackAql(context, $2) || !TRI_StartScopeContextAql(context)) {
YYABORT;
}
} T_ASSIGN T_OPEN expression T_CLOSE {
TRI_aql_node_t* node;
TRI_EndScopeParseContextAql(context);
TRI_EndScopeContextAql(context);
node = TRI_CreateNodeAssignAql(context, TRI_PopStackAql(context), $6);
if (!node) {

46
Ahuacatl/ahuacatl-parser.c
View File

@ -102,11 +102,11 @@ static bool EqualVariable (TRI_associative_pointer_t* array,
/// @brief create and initialize a parse context
////////////////////////////////////////////////////////////////////////////////
TRI_aql_parse_context_t* TRI_CreateParseContextAql (TRI_vocbase_t* vocbase,
TRI_aql_context_t* TRI_CreateContextAql (TRI_vocbase_t* vocbase,
const char* const query) {
TRI_aql_parse_context_t* context;
TRI_aql_context_t* context;
context = (TRI_aql_parse_context_t*) TRI_Allocate(sizeof(TRI_aql_parse_context_t));
context = (TRI_aql_context_t*) TRI_Allocate(sizeof(TRI_aql_context_t));
if (!context) {
return NULL;
}
@ -148,13 +148,13 @@ TRI_aql_parse_context_t* TRI_CreateParseContextAql (TRI_vocbase_t* vocbase,
context->_query = TRI_DuplicateString(query);
if (!context->_query) {
TRI_FreeParseContextAql(context);
TRI_FreeContextAql(context);
return NULL;
}
context->_parser = (TRI_aql_parser_t*) TRI_Allocate(sizeof(TRI_aql_parser_t));
if (!context->_parser) {
TRI_FreeParseContextAql(context);
TRI_FreeContextAql(context);
return NULL;
}
@ -171,7 +171,7 @@ TRI_aql_parse_context_t* TRI_CreateParseContextAql (TRI_vocbase_t* vocbase,
/// @brief free a parse context
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeParseContextAql (TRI_aql_parse_context_t* const context) {
void TRI_FreeContextAql (TRI_aql_context_t* const context) {
size_t i;
assert(context);
@ -187,7 +187,7 @@ void TRI_FreeParseContextAql (TRI_aql_parse_context_t* const context) {
// free all remaining scopes
while (context->_scopes._length) {
TRI_EndScopeParseContextAql(context);
TRI_EndScopeContextAql(context);
}
TRI_DestroyVectorPointer(&context->_scopes);
@ -258,7 +258,7 @@ void TRI_FreeParseContextAql (TRI_aql_parse_context_t* const context) {
/// @brief add bind parameters to the context
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddBindParametersAql (TRI_aql_parse_context_t* const context,
bool TRI_AddBindParametersAql (TRI_aql_context_t* const context,
const TRI_json_t* const parameters) {
return TRI_AddParameterValuesAql(context, parameters);
}
@ -267,7 +267,7 @@ bool TRI_AddBindParametersAql (TRI_aql_parse_context_t* const context,
/// @brief parse & validate the query string
////////////////////////////////////////////////////////////////////////////////
bool TRI_ParseQueryAql (TRI_aql_parse_context_t* const context) {
bool TRI_ParseQueryAql (TRI_aql_context_t* const context) {
// parse the query
if (Ahuacatlparse(context)) {
// lexing/parsing failed
@ -364,7 +364,7 @@ void TRI_FreeScopeAql (TRI_aql_scope_t* const scope) {
/// @brief register a node
////////////////////////////////////////////////////////////////////////////////
bool TRI_RegisterNodeParseContextAql (TRI_aql_parse_context_t* const context,
bool TRI_RegisterNodeContextAql (TRI_aql_context_t* const context,
void* const node) {
assert(context);
assert(node);
@ -378,7 +378,7 @@ bool TRI_RegisterNodeParseContextAql (TRI_aql_parse_context_t* const context,
/// @brief register an error
////////////////////////////////////////////////////////////////////////////////
void TRI_SetErrorAql (TRI_aql_parse_context_t* const context,
void TRI_SetErrorAql (TRI_aql_context_t* const context,
const int code,
const char* const data) {
@ -400,7 +400,7 @@ void TRI_SetErrorAql (TRI_aql_parse_context_t* const context,
/// @brief register a parse error
////////////////////////////////////////////////////////////////////////////////
void TRI_SetParseErrorAql (TRI_aql_parse_context_t* const context,
void TRI_SetParseErrorAql (TRI_aql_context_t* const context,
const char* const message,
const int line,
const int column) {
@ -421,7 +421,7 @@ void TRI_SetParseErrorAql (TRI_aql_parse_context_t* const context,
/// @brief push something on the stack
////////////////////////////////////////////////////////////////////////////////
bool TRI_PushStackAql (TRI_aql_parse_context_t* const context,
bool TRI_PushStackAql (TRI_aql_context_t* const context,
const void* const value) {
assert(context);
@ -438,7 +438,7 @@ bool TRI_PushStackAql (TRI_aql_parse_context_t* const context,
/// @brief pop something from the stack
////////////////////////////////////////////////////////////////////////////////
void* TRI_PopStackAql (TRI_aql_parse_context_t* const context) {
void* TRI_PopStackAql (TRI_aql_context_t* const context) {
assert(context);
assert(context->_stack._length > 0);
@ -449,7 +449,7 @@ void* TRI_PopStackAql (TRI_aql_parse_context_t* const context) {
/// @brief peek at the end of the stack
////////////////////////////////////////////////////////////////////////////////
void* TRI_PeekStackAql (TRI_aql_parse_context_t* const context) {
void* TRI_PeekStackAql (TRI_aql_context_t* const context) {
assert(context);
assert(context->_stack._length > 0);
@ -460,7 +460,7 @@ void* TRI_PeekStackAql (TRI_aql_parse_context_t* const context) {
/// @brief get first statement in the current scope
////////////////////////////////////////////////////////////////////////////////
void* TRI_GetFirstStatementAql (TRI_aql_parse_context_t* const context) {
void* TRI_GetFirstStatementAql (TRI_aql_context_t* const context) {
TRI_aql_scope_t* scope;
size_t length;
@ -480,7 +480,7 @@ void* TRI_GetFirstStatementAql (TRI_aql_parse_context_t* const context) {
/// @brief add a statement to the current scope
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddStatementAql (TRI_aql_parse_context_t* const context,
bool TRI_AddStatementAql (TRI_aql_context_t* const context,
const void* const statement) {
TRI_aql_scope_t* scope;
size_t length;
@ -516,7 +516,7 @@ bool TRI_AddStatementAql (TRI_aql_parse_context_t* const context,
/// @brief create a new variable scope and stack it in the parser context
////////////////////////////////////////////////////////////////////////////////
TRI_aql_scope_t* TRI_StartScopeParseContextAql (TRI_aql_parse_context_t* const context) {
TRI_aql_scope_t* TRI_StartScopeContextAql (TRI_aql_context_t* const context) {
TRI_aql_scope_t* scope;
assert(context);
@ -534,7 +534,7 @@ TRI_aql_scope_t* TRI_StartScopeParseContextAql (TRI_aql_parse_context_t* const c
/// @brief remove a variable scope from parser context scopes stack
////////////////////////////////////////////////////////////////////////////////
void TRI_EndScopeParseContextAql (TRI_aql_parse_context_t* const context) {
void TRI_EndScopeContextAql (TRI_aql_context_t* const context) {
TRI_aql_scope_t* scope;
size_t length;
//size_t i;
@ -562,7 +562,7 @@ for (i = 0; i < scope->_variables._nrAlloc; i++) {
/// @brief move the contents of the outermost variable scope into the previous
////////////////////////////////////////////////////////////////////////////////
bool TRI_ExchangeScopeParseContextAql (TRI_aql_parse_context_t* const context) {
bool TRI_ExchangeScopeContextAql (TRI_aql_context_t* const context) {
TRI_aql_scope_t* scope;
size_t length;
@ -588,7 +588,7 @@ printf("EXCHANGING SCOPE\n");
/// @brief push a variable into the current scope context
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddVariableParseContextAql (TRI_aql_parse_context_t* const context, const char* name) {
bool TRI_AddVariableContextAql (TRI_aql_context_t* const context, const char* name) {
TRI_aql_variable_t* variable;
TRI_aql_scope_t* scope;
size_t current;
@ -653,7 +653,7 @@ void TRI_FreeVariableAql (TRI_aql_variable_t* const variable) {
/// @brief register a string
////////////////////////////////////////////////////////////////////////////////
char* TRI_RegisterStringAql (TRI_aql_parse_context_t* const context,
char* TRI_RegisterStringAql (TRI_aql_context_t* const context,
const char* const value,
const size_t length) {
char* copy;
@ -677,7 +677,7 @@ char* TRI_RegisterStringAql (TRI_aql_parse_context_t* const context,
/// @brief checks if a variable is defined in the current scope or above
////////////////////////////////////////////////////////////////////////////////
bool TRI_VariableExistsAql (TRI_aql_parse_context_t* const context,
bool TRI_VariableExistsAql (TRI_aql_context_t* const context,
const char* const name) {
size_t current = context->_scopes._length;

42
Ahuacatl/ahuacatl-parser.h
View File

@ -103,7 +103,7 @@ typedef struct TRI_aql_parse_context_s {
void* _first;
char* _query;
}
TRI_aql_parse_context_t;
TRI_aql_context_t;
////////////////////////////////////////////////////////////////////////////////
/// @}
@ -122,27 +122,27 @@ TRI_aql_parse_context_t;
/// @brief create and initialize a parse context
////////////////////////////////////////////////////////////////////////////////
TRI_aql_parse_context_t* TRI_CreateParseContextAql (TRI_vocbase_t*,
TRI_aql_context_t* TRI_CreateContextAql (TRI_vocbase_t*,
const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief free a parse context
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeParseContextAql (TRI_aql_parse_context_t* const);
void TRI_FreeContextAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief add bind parameters to the context
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddBindParametersAql (TRI_aql_parse_context_t* const,
bool TRI_AddBindParametersAql (TRI_aql_context_t* const,
const TRI_json_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief parse & validate the query string
////////////////////////////////////////////////////////////////////////////////
bool TRI_ParseQueryAql (TRI_aql_parse_context_t* const);
bool TRI_ParseQueryAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create a new variable scope
@ -160,14 +160,14 @@ void TRI_FreeScopeAql (TRI_aql_scope_t* const);
/// @brief register a node
////////////////////////////////////////////////////////////////////////////////
bool TRI_RegisterNodeParseContextAql (TRI_aql_parse_context_t* const,
bool TRI_RegisterNodeContextAql (TRI_aql_context_t* const,
void* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief register an error
////////////////////////////////////////////////////////////////////////////////
void TRI_SetErrorAql (TRI_aql_parse_context_t* const,
void TRI_SetErrorAql (TRI_aql_context_t* const,
const int,
const char* const);
@ -175,7 +175,7 @@ void TRI_SetErrorAql (TRI_aql_parse_context_t* const,
/// @brief register a parse error
////////////////////////////////////////////////////////////////////////////////
void TRI_SetParseErrorAql (TRI_aql_parse_context_t* const,
void TRI_SetParseErrorAql (TRI_aql_context_t* const,
const char* const,
const int,
const int);
@ -184,55 +184,55 @@ void TRI_SetParseErrorAql (TRI_aql_parse_context_t* const,
/// @brief push something on the stack
////////////////////////////////////////////////////////////////////////////////
bool TRI_PushStackAql (TRI_aql_parse_context_t* const, const void* const);
bool TRI_PushStackAql (TRI_aql_context_t* const, const void* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief pop something from the stack
////////////////////////////////////////////////////////////////////////////////
void* TRI_PopStackAql (TRI_aql_parse_context_t* const);
void* TRI_PopStackAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief peek at the end of the stack
////////////////////////////////////////////////////////////////////////////////
void* TRI_PeekStackAql (TRI_aql_parse_context_t* const);
void* TRI_PeekStackAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief get first statement in the current scope
////////////////////////////////////////////////////////////////////////////////
void* TRI_GetFirstStatementAql (TRI_aql_parse_context_t* const);
void* TRI_GetFirstStatementAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief add a statement to the current context
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddStatementAql (TRI_aql_parse_context_t* const, const void* const);
bool TRI_AddStatementAql (TRI_aql_context_t* const, const void* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief create a new variable scope and stack it in the parser context
////////////////////////////////////////////////////////////////////////////////
TRI_aql_scope_t* TRI_StartScopeParseContextAql (TRI_aql_parse_context_t* const);
TRI_aql_scope_t* TRI_StartScopeContextAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief remove a variable scope from parser context scopes stack
////////////////////////////////////////////////////////////////////////////////
void TRI_EndScopeParseContextAql (TRI_aql_parse_context_t* const);
void TRI_EndScopeContextAql (TRI_aql_context_t* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief move the contents of the outermost variable scope into the previous
////////////////////////////////////////////////////////////////////////////////
bool TRI_ExchangeScopeParseContextAql (TRI_aql_parse_context_t* const context);
bool TRI_ExchangeScopeContextAql (TRI_aql_context_t* const context);
////////////////////////////////////////////////////////////////////////////////
/// @brief push a variable into the current scope context
////////////////////////////////////////////////////////////////////////////////
bool TRI_AddVariableParseContextAql (TRI_aql_parse_context_t* const, const char*);
bool TRI_AddVariableContextAql (TRI_aql_context_t* const, const char*);
////////////////////////////////////////////////////////////////////////////////
/// @brief register a new variable
@ -250,7 +250,7 @@ void TRI_FreeVariableAql (TRI_aql_variable_t* const);
/// @brief register a string
////////////////////////////////////////////////////////////////////////////////
char* TRI_RegisterStringAql (TRI_aql_parse_context_t* const,
char* TRI_RegisterStringAql (TRI_aql_context_t* const,
const char* const,
const size_t);
@ -258,7 +258,7 @@ char* TRI_RegisterStringAql (TRI_aql_parse_context_t* const,
/// @brief checks if a variable is defined in the current scope or above
////////////////////////////////////////////////////////////////////////////////
bool TRI_VariableExistsAql (TRI_aql_parse_context_t* const, const char* const);
bool TRI_VariableExistsAql (TRI_aql_context_t* const, const char* const);
////////////////////////////////////////////////////////////////////////////////
/// @brief checks if a variable name follows the required naming convention
@ -283,11 +283,11 @@ bool TRI_IsValidVariableNameAql (const char* const);
/// @brief forwards for functions provided by the lexer (tokens.c)
////////////////////////////////////////////////////////////////////////////////
int Ahuacatlparse (TRI_aql_parse_context_t* const);
int Ahuacatlparse (TRI_aql_context_t* const);
int Ahuacatllex_destroy (void *);
void Ahuacatlset_extra (TRI_aql_parse_context_t* const, void*);
void Ahuacatlset_extra (TRI_aql_context_t* const, void*);
int Ahuacatllex_init (void**);

2
Ahuacatl/ahuacatl-tokens.c
View File

@ -655,7 +655,7 @@ static yyconst flex_int16_t yy_rule_linenum[47] =
#include "Ahuacatl/ahuacatl-parser.h"
#include "Ahuacatl/ahuacatl-grammar.h"
#define YY_EXTRA_TYPE TRI_aql_parse_context_t*
#define YY_EXTRA_TYPE TRI_aql_context_t*
#define YY_USER_ACTION yylloc->first_line = yylineno; yylloc->first_column = yycolumn; yylloc->last_column = yycolumn + yyleng - 1; yycolumn += yyleng;

2
Ahuacatl/ahuacatl-tokens.l
View File

@ -15,7 +15,7 @@
#include "Ahuacatl/ahuacatl-parser.h"
#include "Ahuacatl/ahuacatl-grammar.h"
#define YY_EXTRA_TYPE TRI_aql_parse_context_t*
#define YY_EXTRA_TYPE TRI_aql_context_t*
#define YY_USER_ACTION yylloc->first_line = yylineno; yylloc->first_column = yycolumn; yylloc->last_column = yycolumn + yyleng - 1; yycolumn += yyleng;

10
V8/v8-vocbase.cpp
View File

@ -2303,8 +2303,8 @@ static v8::Handle<v8::Value> JS_RunAhuacatl (v8::Arguments const& argv) {
TRI_json_t* parameters = NULL;
TRI_aql_parse_context_t* context;
context = TRI_CreateParseContextAql(vocbase, queryString.c_str());
TRI_aql_context_t* context;
context = TRI_CreateContextAql(vocbase, queryString.c_str());
if (!context) {
return scope.Close(v8::ThrowException(v8::String::New("out of memory")));
}
@ -2314,7 +2314,7 @@ static v8::Handle<v8::Value> JS_RunAhuacatl (v8::Arguments const& argv) {
if (!TRI_AddBindParametersAql(context, parameters)) {
v8::Handle<v8::Object> errorObject = CreateErrorObjectAhuacatl(&context->_error);
TRI_FreeJson(parameters);
TRI_FreeParseContextAql(context);
TRI_FreeContextAql(context);
return scope.Close(errorObject);
}
}
@ -2325,7 +2325,7 @@ static v8::Handle<v8::Value> JS_RunAhuacatl (v8::Arguments const& argv) {
if (!TRI_ParseQueryAql(context)) {
v8::Handle<v8::Object> errorObject = CreateErrorObjectAhuacatl(&context->_error);
TRI_FreeParseContextAql(context);
TRI_FreeContextAql(context);
return scope.Close(errorObject);
}
@ -2338,7 +2338,7 @@ static v8::Handle<v8::Value> JS_RunAhuacatl (v8::Arguments const& argv) {
}
}
TRI_FreeParseContextAql(context);
TRI_FreeContextAql(context);
return scope.Close(result);
}