GNU Octave  3.8.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
pt-loop.h
Go to the documentation of this file.
1 /*
2 
3 Copyright (C) 1996-2013 John W. Eaton
4 
5 This file is part of Octave.
6 
7 Octave is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3 of the License, or (at your
10 option) any later version.
11 
12 Octave is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16 
17 You should have received a copy of the GNU General Public License
18 along with Octave; see the file COPYING. If not, see
19 <http://www.gnu.org/licenses/>.
20 
21 */
22 
23 #if !defined (octave_pt_loop_h)
24 #define octave_pt_loop_h 1
25 
26 class octave_value;
27 class octave_lvalue;
28 
29 class tree_argument_list;
30 class tree_expression;
32 
33 class tree_walker;
34 
35 #include "comment-list.h"
36 #include "pt-cmd.h"
37 #include "symtab.h"
38 
39 class jit_info;
40 
41 // While.
42 
43 class
45 {
46 public:
47 
48  tree_while_command (int l = -1, int c = -1)
49  : tree_command (l, c), expr (0), list (0), lead_comm (0),
50  trail_comm (0)
51 #ifdef HAVE_LLVM
52  , compiled (0)
53 #endif
54  { }
55 
57  octave_comment_list *lc = 0,
58  octave_comment_list *tc = 0,
59  int l = -1, int c = -1)
60  : tree_command (l, c), expr (e), list (0), lead_comm (lc),
61  trail_comm (tc)
62 #ifdef HAVE_LLVM
63  , compiled (0)
64 #endif
65  { }
66 
68  octave_comment_list *lc = 0,
69  octave_comment_list *tc = 0,
70  int l = -1, int c = -1)
71  : tree_command (l, c), expr (e), list (lst), lead_comm (lc),
72  trail_comm (tc)
73 #ifdef HAVE_LLVM
74  , compiled (0)
75 #endif
76  { }
77 
78  ~tree_while_command (void);
79 
80  tree_expression *condition (void) { return expr; }
81 
82  tree_statement_list *body (void) { return list; }
83 
84  octave_comment_list *leading_comment (void) { return lead_comm; }
85 
86  octave_comment_list *trailing_comment (void) { return trail_comm; }
87 
90 
91  void accept (tree_walker& tw);
92 
93 #ifdef HAVE_LLVM
94  // some functions use by tree_jit
95  jit_info *get_info (void) const
96  {
97  return compiled;
98  }
99 
100  void stash_info (jit_info *jinfo)
101  {
102  compiled = jinfo;
103  }
104 #endif
105 
106 protected:
107 
108  // Expression to test.
110 
111  // List of commands to execute.
113 
114  // Comment preceding WHILE token.
116 
117  // Comment preceding ENDWHILE token.
119 
120 private:
121 
122 #ifdef HAVE_LLVM
123  // compiled version of the loop
125 #endif
126 
127  // No copying!
128 
130 
131  tree_while_command& operator = (const tree_while_command&);
132 };
133 
134 // Do-Until.
135 
136 class
138 {
139 public:
140 
141  tree_do_until_command (int l = -1, int c = -1)
142  : tree_while_command (l, c) { }
143 
145  octave_comment_list *lc = 0,
146  octave_comment_list *tc = 0,
147  int l = -1, int c = -1)
148  : tree_while_command (e, lc, tc, l, c) { }
149 
151  octave_comment_list *lc = 0,
152  octave_comment_list *tc = 0,
153  int l = -1, int c = -1)
154  : tree_while_command (e, lst, lc, tc, l, c) { }
155 
157 
160 
161  void accept (tree_walker& tw);
162 
163 private:
164 
165  // No copying!
166 
168 
169  tree_do_until_command& operator = (const tree_do_until_command&);
170 };
171 
172 // For.
173 
174 class
176 {
177 public:
178 
179  tree_simple_for_command (int l = -1, int c = -1)
180  : tree_command (l, c), parallel (false), lhs (0), expr (0),
181  maxproc (0), list (0), lead_comm (0), trail_comm (0)
182 #ifdef HAVE_LLVM
183  , compiled (0)
184 #endif
185  { }
186 
187  tree_simple_for_command (bool parallel_arg, tree_expression *le,
188  tree_expression *re,
189  tree_expression *maxproc_arg,
190  tree_statement_list *lst,
191  octave_comment_list *lc = 0,
192  octave_comment_list *tc = 0,
193  int l = -1, int c = -1)
194  : tree_command (l, c), parallel (parallel_arg), lhs (le),
195  expr (re), maxproc (maxproc_arg), list (lst),
196  lead_comm (lc), trail_comm (tc)
197 #ifdef HAVE_LLVM
198  , compiled (0)
199 #endif
200  { }
201 
202  ~tree_simple_for_command (void);
203 
204  bool in_parallel (void) { return parallel; }
205 
206  tree_expression *left_hand_side (void) { return lhs; }
207 
208  tree_expression *control_expr (void) { return expr; }
209 
210  tree_expression *maxproc_expr (void) { return maxproc; }
211 
212  tree_statement_list *body (void) { return list; }
213 
214  octave_comment_list *leading_comment (void) { return lead_comm; }
215 
216  octave_comment_list *trailing_comment (void) { return trail_comm; }
217 
220 
221  void accept (tree_walker& tw);
222 
223 #ifdef HAVE_LLVM
224  // some functions use by tree_jit
225  jit_info *get_info (void) const
226  {
227  return compiled;
228  }
229 
230  void stash_info (jit_info *jinfo)
231  {
232  compiled = jinfo;
233  }
234 #endif
235 
236 private:
237  // TRUE means operate in parallel (subject to the value of the
238  // maxproc expression).
239  bool parallel;
240 
241  // Expression to modify.
243 
244  // Expression to evaluate.
246 
247  // Expression to tell how many processors should be used (only valid
248  // if parallel is TRUE).
250 
251  // List of commands to execute.
253 
254  // Comment preceding FOR token.
256 
257  // Comment preceding ENDFOR token.
259 
260  // compiled version of the loop
262 
263  // No copying!
264 
266 
268 };
269 
270 class
272 {
273 public:
274 
275  tree_complex_for_command (int l = -1, int c = -1)
276  : tree_command (l, c), lhs (0), expr (0), list (0), lead_comm (0),
277  trail_comm (0) { }
278 
280  tree_statement_list *lst,
281  octave_comment_list *lc = 0,
282  octave_comment_list *tc = 0,
283  int l = -1, int c = -1)
284  : tree_command (l, c), lhs (le), expr (re), list (lst),
285  lead_comm (lc), trail_comm (tc) { }
286 
287  ~tree_complex_for_command (void);
288 
289  tree_argument_list *left_hand_side (void) { return lhs; }
290 
291  tree_expression *control_expr (void) { return expr; }
292 
293  tree_statement_list *body (void) { return list; }
294 
295  octave_comment_list *leading_comment (void) { return lead_comm; }
296 
297  octave_comment_list *trailing_comment (void) { return trail_comm; }
298 
301 
302  void accept (tree_walker& tw);
303 
304 private:
305 
306  // Expression to modify.
308 
309  // Expression to evaluate.
311 
312  // List of commands to execute.
314 
315  // Comment preceding FOR token.
317 
318  // Comment preceding ENDFOR token.
320 
321  // No copying!
322 
324 
326 };
327 
328 #endif