Mercurial > octave

comparison src/pt-exp.h @ 2980:cd5ad3fd8049

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1997-05-16 01:12:13 by jwe]
author jwe
date Fri, 16 May 1997 01:13:19 +0000
parents a3556d2adec9
children daa1ed1f5462
comparison
equal deleted inserted replaced
2979:a3556d2adec9 2980:cd5ad3fd8049
18 along with Octave; see the file COPYING. If not, write to the Free 18 along with Octave; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 20
21 */ 21 */
22 22
23 #if !defined (octave_tree_expr2_h) 23 #if !defined (octave_tree_expr_h)
24 #define octave_tree_expr2_h 1 24 #define octave_tree_expr_h 1
25 25
26 #if defined (__GNUG__) 26 #if defined (__GNUG__)
27 #pragma interface 27 #pragma interface
28 #endif 28 #endif
29 29
30 class ostream; 30 #include <string>
31
32 class tree_identifier;
33 class tree_index_expression;
34 class tree_indirect_ref;
35 class tree_argument_list;
36 class tree_assignment_lhs;
37
38 class tree_walker;
39 31
40 class octave_value; 32 class octave_value;
41 class octave_value_list;
42 class octave_lvalue; 33 class octave_lvalue;
43 34
44 #include "oct-obj.h" 35 #include "pt-base.h"
45 #include "pt-exp-base.h"
46 36
47 // Unary expressions. 37 // A base class for expressions.
48 38
49 class 39 class
50 tree_unary_expression : public tree_expression 40 tree_expression : public tree
51 { 41 {
52 public: 42 public:
53 43
54 tree_unary_expression (int l = -1, int c = -1) 44 tree_expression (int l = -1, int c = -1)
55 : tree_expression (l, c), op (0) { } 45 : tree (l, c), num_parens (0), postfix_indexed (false),
46 print_flag (false) { }
56 47
57 tree_unary_expression (tree_expression *e, int l = -1, int c = -1) 48 virtual ~tree_expression (void) { }
58 : tree_expression (l, c), op (e) { }
59 49
60 ~tree_unary_expression (void) { delete op; } 50 virtual bool is_constant (void) const
51 { return false; }
61 52
62 tree_expression *operand (void) { return op; } 53 virtual bool is_matrix_constant (void) const
54 { return false; }
55
56 virtual bool is_identifier (void) const
57 { return false; }
58
59 virtual bool is_index_expression (void) const
60 { return false; }
61
62 virtual bool is_indirect_ref (void) const
63 { return false; }
64
65 virtual bool is_assignment_expression (void) const
66 { return false; }
67
68 virtual bool is_prefix_expression (void) const
69 { return false; }
70
71 virtual bool is_logically_true (const char *);
72
73 virtual bool lvalue_ok (void) const
74 { return false; }
75
76 virtual bool rvalue_ok (void) const
77 { return false; }
78
79 virtual octave_value rvalue (void);
80
81 virtual octave_value_list rvalue (int nargout);
82
83 virtual octave_lvalue lvalue (void);
84
85 int paren_count (void) const
86 { return num_parens; }
87
88 bool is_postfix_indexed (void) const
89 { return postfix_indexed; }
90
91 bool print_result (void) const
92 { return print_flag; }
93
94 virtual string oper (void) const
95 { return "<unknown>"; }
96
97 virtual string name (void) const
98 { return "<unknown>"; }
99
100 virtual string original_text (void) const;
101
102 tree_expression *mark_in_parens (void)
103 {
104 num_parens++;
105 return this;
106 }
107
108 tree_expression *mark_postfix_indexed (void)
109 {
110 postfix_indexed = true;
111 return this;
112 }
113
114 tree_expression *set_print_flag (bool print)
115 {
116 print_flag = print;
117 return this;
118 }
63 119
64 protected: 120 protected:
65 121
66 // The operand for the expression. 122 // A count of the number of times this expression appears directly
67 tree_expression *op; 123 // inside a set of parentheses.
68 }; 124 //
125 // (((e1)) + e2) ==> 2 for expression e1
126 // ==> 1 for expression ((e1)) + e2
127 // ==> 0 for expression e2
128 int num_parens;
69 129
70 // Prefix expressions. 130 // A flag that says whether this expression has an index associated
131 // with it. See the code in tree_identifier::rvalue for the rationale.
132 bool postfix_indexed;
71 133
72 class 134 // Print result of rvalue for this expression?
73 tree_prefix_expression : public tree_unary_expression 135 bool print_flag;
74 {
75 public:
76
77 enum type
78 {
79 unknown,
80 unot,
81 uminus,
82 increment,
83 decrement
84 };
85
86 tree_prefix_expression (int l = -1, int c = -1)
87 : tree_unary_expression (l, c), etype (unknown) { }
88
89 tree_prefix_expression (type t = unknown, tree_expression *e,
90 int l = -1, int c = -1)
91 : tree_unary_expression (e, l, c), etype (t) { }
92
93 ~tree_prefix_expression (void) { }
94
95 bool rvalue_ok (void) const
96 { return true; }
97
98 octave_value rvalue (void);
99
100 octave_value_list rvalue (int nargou);
101
102 void eval_error (void);
103
104 string oper (void) const;
105
106 void accept (tree_walker& tw);
107
108 private:
109
110 // The type of the expression.
111 type etype;
112 };
113
114 // Postfix expressions.
115
116 class
117 tree_postfix_expression : public tree_unary_expression
118 {
119 public:
120
121 enum type
122 {
123 unknown,
124 hermitian,
125 transpose,
126 increment,
127 decrement
128 };
129
130 tree_postfix_expression (int l = -1, int c = -1)
131 : tree_unary_expression (l, c), etype (unknown) { }
132
133 tree_postfix_expression (type t = unknown, tree_expression *e,
134 int l = -1, int c = -1)
135 : tree_unary_expression (e, l, c), etype (t) { }
136
137 ~tree_postfix_expression (void) { }
138
139 bool rvalue_ok (void) const
140 { return true; }
141
142 octave_value rvalue (void);
143
144 octave_value_list rvalue (int nargout);
145
146 void eval_error (void);
147
148 string oper (void) const;
149
150 void accept (tree_walker& tw);
151
152 private:
153
154 // The type of the expression.
155 type etype;
156 };
157
158 // Binary expressions.
159
160 class
161 tree_binary_expression : public tree_expression
162 {
163 public:
164
165 tree_binary_expression (int l = -1, int c = -1,
166 octave_value::binary_op t
167 = octave_value::unknown_binary_op)
168 : tree_expression (l, c), op_lhs (0), op_rhs (0), etype (t) { }
169
170 tree_binary_expression (tree_expression *a, tree_expression *b,
171 int l = -1, int c = -1,
172 octave_value::binary_op t
173 = octave_value::unknown_binary_op)
174 : tree_expression (l, c), op_lhs (a), op_rhs (b), etype (t) { }
175
176 ~tree_binary_expression (void)
177 {
178 delete op_lhs;
179 delete op_rhs;
180 }
181
182 bool rvalue_ok (void) const
183 { return true; }
184
185 octave_value rvalue (void);
186
187 octave_value_list rvalue (int nargou);
188
189 void eval_error (void);
190
191 string oper (void) const;
192
193 tree_expression *lhs (void) { return op_lhs; }
194 tree_expression *rhs (void) { return op_rhs; }
195
196 void accept (tree_walker& tw);
197
198 protected:
199
200 // The operands for the expression.
201 tree_expression *op_lhs;
202 tree_expression *op_rhs;
203
204 private:
205
206 // The type of the expression.
207 octave_value::binary_op etype;
208 };
209
210 // Boolean expressions.
211
212 class
213 tree_boolean_expression : public tree_binary_expression
214 {
215 public:
216
217 enum type
218 {
219 unknown,
220 bool_and,
221 bool_or
222 };
223
224 tree_boolean_expression (int l = -1, int c = -1, type t = unknown)
225 : tree_binary_expression (l, c), etype (t) { }
226
227 tree_boolean_expression (tree_expression *a, tree_expression *b,
228 int l = -1, int c = -1, type t = unknown)
229 : tree_binary_expression (a, b, l, c), etype (t) { }
230
231 ~tree_boolean_expression (void) { }
232
233 bool rvalue_ok (void) const
234 { return true; }
235
236 octave_value rvalue (void);
237
238 octave_value_list rvalue (int nargout);
239
240 string oper (void) const;
241
242 private:
243
244 // The type of the expression.
245 type etype;
246 };
247
248 // Simple assignment expressions.
249
250 class
251 tree_simple_assignment : public tree_expression
252 {
253 public:
254
255 tree_simple_assignment (bool plhs = false, int l = -1, int c = -1,
256 octave_value::assign_op t = octave_value::asn_eq)
257 : tree_expression (l, c), lhs (0), rhs (0), preserve (plhs), etype (t) { }
258
259 tree_simple_assignment (tree_expression *le, tree_expression *re,
260 bool plhs = false, int l = -1, int c = -1,
261 octave_value::assign_op t = octave_value::asn_eq)
262 : tree_expression (l, c), lhs (le), rhs (re), preserve (plhs),
263 etype (t) { }
264
265 ~tree_simple_assignment (void);
266
267 bool rvalue_ok (void) const
268 { return true; }
269
270 octave_value rvalue (void);
271
272 octave_value_list rvalue (int nargout);
273
274 bool is_assignment_expression (void) const
275 { return true; }
276
277 void eval_error (void);
278
279 string oper (void) const;
280
281 tree_expression *left_hand_side (void) { return lhs; }
282
283 tree_expression *right_hand_side (void) { return rhs; }
284
285 void accept (tree_walker& tw);
286
287 private:
288
289 void do_assign (octave_lvalue& ult, const octave_value_list& args,
290 const octave_value& rhs_val);
291
292 void do_assign (octave_lvalue& ult, const octave_value& rhs_val);
293
294 // The left hand side of the assignment.
295 tree_expression *lhs;
296
297 // The right hand side of the assignment.
298 tree_expression *rhs;
299
300 // True if we should not delete the lhs.
301 bool preserve;
302
303 // True if this is an assignment to the built-in variable ans.
304 bool ans_ass;
305
306 // The type of the expression.
307 octave_value::assign_op etype;
308 };
309
310 // Colon expressions.
311
312 class
313 tree_colon_expression : public tree_expression
314 {
315 public:
316
317 tree_colon_expression (int l = -1, int c = -1)
318 : tree_expression (l, c), op_base (0), op_limit (0), op_increment (0) { }
319
320 tree_colon_expression (tree_expression *e, int l = -1, int c = -1)
321 : tree_expression (l, c), op_base (e), op_limit (0), op_increment (0) { }
322
323 ~tree_colon_expression (void)
324 {
325 delete op_base;
326 delete op_limit;
327 delete op_increment;
328 }
329
330 tree_colon_expression *append (tree_expression *t);
331
332 bool rvalue_ok (void) const
333 { return true; }
334
335 octave_value rvalue (void);
336
337 octave_value_list rvalue (int nargout);
338
339 void eval_error (const string& s = string ());
340
341 tree_expression *base (void) { return op_base; }
342 tree_expression *limit (void) { return op_limit; }
343 tree_expression *increment (void) { return op_increment; }
344
345 void accept (tree_walker& tw);
346
347 private:
348
349 // The components of the expression.
350 tree_expression *op_base;
351 tree_expression *op_limit;
352 tree_expression *op_increment;
353 };
354
355 // Index expressions.
356
357 class
358 tree_index_expression : public tree_expression
359 {
360 public:
361
362 tree_index_expression (tree_expression *e = 0, tree_argument_list *lst = 0,
363 int l = -1, int c = -1)
364 : tree_expression (l, c), expr (e), list (lst), arg_nm () { }
365
366 ~tree_index_expression (void);
367
368 bool is_index_expression (void) const
369 { return true; }
370
371 tree_expression *expression (void)
372 { return expr; }
373
374 tree_argument_list *arg_list (void)
375 { return list; }
376
377 bool rvalue_ok (void) const
378 { return true; }
379
380 octave_value rvalue (void);
381
382 octave_value_list rvalue (int nargout);
383
384 octave_lvalue lvalue (void);
385
386 void eval_error (void);
387
388 void accept (tree_walker& tw);
389
390 private:
391
392 tree_expression *expr;
393
394 tree_argument_list *list;
395
396 string_vector arg_nm;
397 };
398
399 // Multi-valued assignment expressions.
400
401 class
402 tree_multi_assignment : public tree_expression
403 {
404 public:
405
406 tree_multi_assignment (bool plhs = false, int l = -1, int c = -1)
407 : tree_expression (l, c), preserve (plhs), lhs (0), rhs (0) { }
408
409 tree_multi_assignment (tree_argument_list *lst, tree_expression *r,
410 bool plhs = false, int l = -1, int c = -1)
411 : tree_expression (l, c), preserve (plhs), lhs (lst), rhs (r) { }
412
413 ~tree_multi_assignment (void);
414
415 bool is_assignment_expression (void) const
416 { return true; }
417
418 bool rvalue_ok (void) const
419 { return true; }
420
421 octave_value rvalue (void);
422
423 octave_value_list rvalue (int nargout);
424
425 void eval_error (void);
426
427 tree_argument_list *left_hand_side (void) { return lhs; }
428
429 tree_expression *right_hand_side (void) { return rhs; }
430
431 void accept (tree_walker& tw);
432
433 private:
434
435 bool preserve;
436 tree_argument_list *lhs;
437 tree_expression *rhs;
438 }; 136 };
439 137
440 #endif 138 #endif
441 139
442 /* 140 /*