Drizzled Public API Documentation

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*
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 /**********************************************************************/
111 UNIV_INTERN
112 que_thr_t*
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*
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*
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*
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*
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 }
sym_node_t * var
Definition: pars0pars.h:729
que_node_t * loop_end_limit
Definition: pars0pars.h:708
que_node_t * stat_list
Definition: pars0pars.h:680
lint loop_end_value
Definition: pars0pars.h:709
UNIV_INTERN que_thr_t * assign_step(que_thr_t *thr)
Definition: eval0proc.cc:149
UNIV_INLINE lint eval_node_get_int_val(que_node_t *node)
UNIV_INTERN que_thr_t * if_step(que_thr_t *thr)
Definition: eval0proc.cc:37
que_node_t * run_node
Definition: que0que.h:376
que_node_t * else_part
Definition: pars0pars.h:688
que_node_t * cond
Definition: pars0pars.h:695
UNIV_INTERN que_thr_t * while_step(que_thr_t *thr)
Definition: eval0proc.cc:113
que_node_t * cond
Definition: pars0pars.h:679
UNIV_INTERN que_node_t * que_node_get_containing_loop_node(que_node_t *node)
Definition: que0que.cc:1067
UNIV_INLINE void eval_exp(que_node_t *exp_node)
UNIV_INLINE void eval_node_copy_val(que_node_t *node1, que_node_t *node2)
#define ut_a(EXPR)
Definition: ut0dbg.h:105
que_node_t * cond
Definition: pars0pars.h:686
que_node_t * stat_list
Definition: pars0pars.h:696
#define ut_ad(EXPR)
Definition: ut0dbg.h:127
UNIV_INLINE ibool eval_node_get_ibool_val(que_node_t *node)
sym_node_t * loop_var
Definition: pars0pars.h:702
que_node_t * stat_list
Definition: pars0pars.h:713
sym_node_t * alias
Definition: pars0sym.h:178
UNIV_INLINE que_node_t * que_node_get_parent(que_node_t *node)
UNIV_INTERN que_thr_t * for_step(que_thr_t *thr)
Definition: eval0proc.cc:176
UNIV_INLINE ulint que_node_get_type(que_node_t *node)
elsif_node_t * elsif_list
Definition: pars0pars.h:689
que_node_t * stat_list
Definition: pars0pars.h:687
UNIV_INTERN que_thr_t * exit_step(que_thr_t *thr)
Definition: eval0proc.cc:238
UNIV_INTERN que_thr_t * return_step(que_thr_t *thr)
Definition: eval0proc.cc:270
que_node_t * prev_node
Definition: que0que.h:379
UNIV_INLINE void eval_node_set_int_val(que_node_t *node, lint val)
UNIV_INLINE que_node_t * que_node_get_next(que_node_t *node)
que_node_t * val
Definition: pars0pars.h:730
que_node_t * loop_start_limit
Definition: pars0pars.h:707