Drizzled Public API Documentation
Main Page
Related Pages
Modules
Namespaces
Classes
Files
File List
File Members
eval0proc.cc
1
/*****************************************************************************
2
3
Copyright (C) 1998, 2009, Innobase Oy. All Rights Reserved.
4
5
This program is free software; you can redistribute it and/or modify it under
6
the terms of the GNU General Public License as published by the Free Software
7
Foundation; version 2 of the License.
8
9
This program is distributed in the hope that it will be useful, but WITHOUT
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
13
You should have received a copy of the GNU General Public License along with
14
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
St, Fifth Floor, Boston, MA 02110-1301 USA
16
17
*****************************************************************************/
18
19
/**************************************************/
26
#include "
eval0proc.h
"
27
28
#ifdef UNIV_NONINL
29
#include "eval0proc.ic"
30
#endif
31
32
/**********************************************************************/
35
UNIV_INTERN
36
que_thr_t
*
37
if_step(
38
/*====*/
39
que_thr_t
* thr)
40
{
41
if_node_t
* node;
42
elsif_node_t
* elsif_node;
43
44
ut_ad
(thr);
45
46
node =
static_cast<
if_node_t
*
>
(thr->
run_node
);
47
ut_ad
(
que_node_get_type
(node) == QUE_NODE_IF);
48
49
if
(thr->
prev_node
==
que_node_get_parent
(node)) {
50
51
/* Evaluate the condition */
52
53
eval_exp
(node->
cond
);
54
55
if
(
eval_node_get_ibool_val
(node->
cond
)) {
56
57
/* The condition evaluated to TRUE: start execution
58
from the first statement in the statement list */
59
60
thr->
run_node
= node->
stat_list
;
61
62
}
else
if
(node->
else_part
) {
63
thr->
run_node
= node->
else_part
;
64
65
}
else
if
(node->
elsif_list
) {
66
elsif_node = node->
elsif_list
;
67
68
for
(;;) {
69
eval_exp
(elsif_node->
cond
);
70
71
if
(
eval_node_get_ibool_val
(
72
elsif_node->
cond
)) {
73
74
/* The condition evaluated to TRUE:
75
start execution from the first
76
statement in the statement list */
77
78
thr->
run_node
= elsif_node->
stat_list
;
79
80
break
;
81
}
82
83
elsif_node =
static_cast<
elsif_node_t
*
>
(
que_node_get_next
(elsif_node));
84
85
if
(elsif_node == NULL) {
86
thr->
run_node
= NULL;
87
88
break
;
89
}
90
}
91
}
else
{
92
thr->
run_node
= NULL;
93
}
94
}
else
{
95
/* Move to the next statement */
96
ut_ad
(
que_node_get_next
(thr->
prev_node
) == NULL);
97
98
thr->
run_node
= NULL;
99
}
100
101
if
(thr->
run_node
== NULL) {
102
thr->
run_node
=
que_node_get_parent
(node);
103
}
104
105
return
(thr);
106
}
107
108
/**********************************************************************/
111
UNIV_INTERN
112
que_thr_t
*
113
while_step(
114
/*=======*/
115
que_thr_t
* thr)
116
{
117
while_node_t
* node;
118
119
ut_ad
(thr);
120
121
node =
static_cast<
while_node_t
*
>
(thr->
run_node
);
122
ut_ad
(
que_node_get_type
(node) == QUE_NODE_WHILE);
123
124
ut_ad
((thr->
prev_node
==
que_node_get_parent
(node))
125
|| (
que_node_get_next
(thr->
prev_node
) == NULL));
126
127
/* Evaluate the condition */
128
129
eval_exp
(node->
cond
);
130
131
if
(
eval_node_get_ibool_val
(node->
cond
)) {
132
133
/* The condition evaluated to TRUE: start execution
134
from the first statement in the statement list */
135
136
thr->
run_node
= node->
stat_list
;
137
}
else
{
138
thr->
run_node
=
que_node_get_parent
(node);
139
}
140
141
return
(thr);
142
}
143
144
/**********************************************************************/
147
UNIV_INTERN
148
que_thr_t
*
149
assign_step(
150
/*========*/
151
que_thr_t
* thr)
152
{
153
assign_node_t
* node;
154
155
ut_ad
(thr);
156
157
node =
static_cast<
assign_node_t
*
>
(thr->
run_node
);
158
ut_ad
(
que_node_get_type
(node) == QUE_NODE_ASSIGNMENT);
159
160
/* Evaluate the value to assign */
161
162
eval_exp
(node->
val
);
163
164
eval_node_copy_val
(node->
var
->
alias
, node->
val
);
165
166
thr->
run_node
=
que_node_get_parent
(node);
167
168
return
(thr);
169
}
170
171
/**********************************************************************/
174
UNIV_INTERN
175
que_thr_t
*
176
for_step(
177
/*=====*/
178
que_thr_t
* thr)
179
{
180
for_node_t
* node;
181
que_node_t* parent;
182
lint loop_var_value;
183
184
ut_ad
(thr);
185
186
node =
static_cast<
for_node_t
*
>
(thr->
run_node
);
187
188
ut_ad
(
que_node_get_type
(node) == QUE_NODE_FOR);
189
190
parent =
que_node_get_parent
(node);
191
192
if
(thr->
prev_node
!= parent) {
193
194
/* Move to the next statement */
195
thr->
run_node
=
que_node_get_next
(thr->
prev_node
);
196
197
if
(thr->
run_node
!= NULL) {
198
199
return
(thr);
200
}
201
202
/* Increment the value of loop_var */
203
204
loop_var_value = 1 +
eval_node_get_int_val
(node->
loop_var
);
205
}
else
{
206
/* Initialize the loop */
207
208
eval_exp
(node->
loop_start_limit
);
209
eval_exp
(node->
loop_end_limit
);
210
211
loop_var_value =
eval_node_get_int_val
(node->
loop_start_limit
);
212
213
node->
loop_end_value
214
= (int)
eval_node_get_int_val
(node->
loop_end_limit
);
215
}
216
217
/* Check if we should do another loop */
218
219
if
(loop_var_value > node->
loop_end_value
) {
220
221
/* Enough loops done */
222
223
thr->
run_node
= parent;
224
}
else
{
225
eval_node_set_int_val
(node->
loop_var
, loop_var_value);
226
227
thr->
run_node
= node->
stat_list
;
228
}
229
230
return
(thr);
231
}
232
233
/**********************************************************************/
236
UNIV_INTERN
237
que_thr_t
*
238
exit_step(
239
/*======*/
240
que_thr_t
* thr)
241
{
242
exit_node_t
* node;
243
que_node_t* loop_node;
244
245
ut_ad
(thr);
246
247
node =
static_cast<
exit_node_t
*
>
(thr->
run_node
);
248
249
ut_ad
(
que_node_get_type
(node) == QUE_NODE_EXIT);
250
251
/* Loops exit by setting thr->run_node as the loop node's parent, so
252
find our containing loop node and get its parent. */
253
254
loop_node =
que_node_get_containing_loop_node
(node);
255
256
/* If someone uses an EXIT statement outside of a loop, this will
257
trigger. */
258
ut_a
(loop_node);
259
260
thr->
run_node
=
que_node_get_parent
(loop_node);
261
262
return
(thr);
263
}
264
265
/**********************************************************************/
268
UNIV_INTERN
269
que_thr_t
*
270
return_step(
271
/*========*/
272
que_thr_t
* thr)
273
{
274
return_node_t
* node;
275
que_node_t* parent;
276
277
ut_ad
(thr);
278
279
node =
static_cast<
return_node_t
*
>
(thr->
run_node
);
280
281
ut_ad
(
que_node_get_type
(node) == QUE_NODE_RETURN);
282
283
parent = node;
284
285
while
(
que_node_get_type
(parent) != QUE_NODE_PROC) {
286
287
parent =
que_node_get_parent
(parent);
288
}
289
290
ut_a
(parent);
291
292
thr->
run_node
=
que_node_get_parent
(parent);
293
294
return
(thr);
295
}
plugin
innobase
eval
eval0proc.cc
Generated on Tue Jun 19 2012 18:56:53 for drizzle by
1.8.1