drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
eval0proc.cc
1/*****************************************************************************
2
3Copyright (C) 1998, 2009, Innobase Oy. All Rights Reserved.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License as published by the Free Software
7Foundation; version 2 of the License.
8
9This program is distributed in the hope that it will be useful, but WITHOUT
10ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
13You should have received a copy of the GNU General Public License along with
14this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15St, Fifth Floor, Boston, MA 02110-1301 USA
16
17*****************************************************************************/
18
19/**************************************************/
25
26#include "eval0proc.h"
27
28#ifdef UNIV_NONINL
29#include "eval0proc.ic"
30#endif
31
32/**********************************************************************/
35UNIV_INTERN
36que_thr_t*
37if_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
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/**********************************************************************/
111UNIV_INTERN
112que_thr_t*
113while_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/**********************************************************************/
147UNIV_INTERN
148que_thr_t*
149assign_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/**********************************************************************/
174UNIV_INTERN
175que_thr_t*
176for_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
210
211 loop_var_value = eval_node_get_int_val(node->loop_start_limit);
212
213 node->loop_end_value
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/**********************************************************************/
236UNIV_INTERN
237que_thr_t*
238exit_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/**********************************************************************/
268UNIV_INTERN
269que_thr_t*
270return_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}
UNIV_INLINE ibool eval_node_get_ibool_val(que_node_t *node)
UNIV_INLINE void eval_node_set_int_val(que_node_t *node, lint val)
UNIV_INLINE void eval_node_copy_val(que_node_t *node1, que_node_t *node2)
UNIV_INLINE void eval_exp(que_node_t *exp_node)
UNIV_INLINE lint eval_node_get_int_val(que_node_t *node)
UNIV_INLINE ulint que_node_get_type(que_node_t *node)
UNIV_INLINE que_node_t * que_node_get_parent(que_node_t *node)
UNIV_INLINE que_node_t * que_node_get_next(que_node_t *node)
UNIV_INTERN que_node_t * que_node_get_containing_loop_node(que_node_t *node)
Definition que0que.cc:1065
sym_node_t * var
Definition pars0pars.h:726
que_node_t * val
Definition pars0pars.h:727
que_node_t * cond
Definition pars0pars.h:676
que_node_t * stat_list
Definition pars0pars.h:677
que_node_t * loop_start_limit
Definition pars0pars.h:704
que_node_t * loop_end_limit
Definition pars0pars.h:705
que_node_t * stat_list
Definition pars0pars.h:710
sym_node_t * loop_var
Definition pars0pars.h:699
elsif_node_t * elsif_list
Definition pars0pars.h:686
que_node_t * cond
Definition pars0pars.h:683
que_node_t * else_part
Definition pars0pars.h:685
que_node_t * stat_list
Definition pars0pars.h:684
sym_node_t * alias
Definition pars0sym.h:178
que_node_t * stat_list
Definition pars0pars.h:693
que_node_t * cond
Definition pars0pars.h:692
#define ut_ad(EXPR)
Definition ut0dbg.h:127
#define ut_a(EXPR)
Definition ut0dbg.h:105