Mercurial > hg > octave-lyh

comparison src/pt-exp-base.h @ 666:fb4f6556b443

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1994-09-06 21:22:46 by jwe]
author jwe
date Tue, 06 Sep 1994 21:25:14 +0000
parents e57b1bd85102
children 1c072f20b522
comparison
equal deleted inserted replaced
665:2aeae851a164 666:fb4f6556b443
113 etype = unknown; 113 etype = unknown;
114 } 114 }
115 115
116 ~tree_expression (void) { } 116 ~tree_expression (void) { }
117 117
118 virtual int is_multi_val_ret_expression (void) const
119 { return 0; }
120
118 virtual int is_identifier (void) const 121 virtual int is_identifier (void) const
119 { return 0; } 122 { return 0; }
120 123
121 virtual int is_index_expression (void) const 124 virtual int is_index_expression (void) const
122 { return 0; } 125 { return 0; }
129 132
130 virtual void mark_for_possible_ans_assign (void) 133 virtual void mark_for_possible_ans_assign (void)
131 { panic_impossible (); } 134 { panic_impossible (); }
132 135
133 virtual tree_constant eval (int print) = 0; 136 virtual tree_constant eval (int print) = 0;
134
135 virtual Octave_object eval (int print, int nargout,
136 const Octave_object& args);
137 137
138 protected: 138 protected:
139 type etype; 139 type etype;
140 }; 140 };
141 141
183 tree_matrix::dir direction; // Direction from the previous element. 183 tree_matrix::dir direction; // Direction from the previous element.
184 tree_expression *element; 184 tree_expression *element;
185 tree_matrix *next; 185 tree_matrix *next;
186 }; 186 };
187 187
188 // A base class for objects that can be return multiple values
189
190 class
191 tree_multi_val_ret : public tree_expression
192 {
193 public:
194 tree_multi_val_ret (int l = -1, int c = -1) : tree_expression (l, c) { }
195
196 int is_multi_val_ret_expression (void) const
197 { return 1; }
198
199 tree_constant eval (int print);
200
201 virtual Octave_object eval (int print, int nargout,
202 const Octave_object& args) = 0;
203 };
204
188 // A base class for objects that can be evaluated with argument lists. 205 // A base class for objects that can be evaluated with argument lists.
189 206
190 class 207 class
191 tree_fvc : public tree_expression 208 tree_fvc : public tree_multi_val_ret
192 { 209 {
193 public: 210 public:
194 tree_fvc (int l = -1, int c = -1) : tree_expression (l, c) { } 211 tree_fvc (int l = -1, int c = -1) : tree_multi_val_ret (l, c) { }
195 212
196 virtual int is_constant (void) const 213 virtual int is_constant (void) const
197 { return 0; } 214 { return 0; }
198
199 // virtual int is_builtin (void) const
200 // { return 0; }
201 215
202 virtual tree_constant assign (tree_constant& t, const Octave_object& args); 216 virtual tree_constant assign (tree_constant& t, const Octave_object& args);
203 217
204 virtual char *name (void) const 218 virtual char *name (void) const
205 { panic_impossible (); return 0; } 219 { panic_impossible (); return 0; }
290 }; 304 };
291 305
292 // Index expressions. 306 // Index expressions.
293 307
294 class 308 class
295 tree_index_expression : public tree_expression 309 tree_index_expression : public tree_multi_val_ret
296 { 310 {
297 public: 311 public:
298 tree_index_expression (int l = -1, int c = -1) : tree_expression (l, c) 312 tree_index_expression (int l = -1, int c = -1) : tree_multi_val_ret (l, c)
299 { 313 {
300 id = 0; 314 id = 0;
301 list = 0; 315 list = 0;
302 } 316 }
303 317
304 tree_index_expression (tree_identifier *i, int l = -1, int c = -1) 318 tree_index_expression (tree_identifier *i, int l = -1, int c = -1)
305 : tree_expression (l, c) 319 : tree_multi_val_ret (l, c)
306 { 320 {
307 id = i; 321 id = i;
308 list = 0; 322 list = 0;
309 } 323 }
310 324
311 tree_index_expression (tree_identifier *i, tree_argument_list *lst, 325 tree_index_expression (tree_identifier *i, tree_argument_list *lst,
312 int l = -1, int c = -1) 326 int l = -1, int c = -1)
313 : tree_expression (l, c) 327 : tree_multi_val_ret (l, c)
314 { 328 {
315 id = i; 329 id = i;
316 list = lst; 330 list = lst;
317 } 331 }
318 332
493 private: 507 private:
494 tree_expression *op1; 508 tree_expression *op1;
495 tree_expression *op2; 509 tree_expression *op2;
496 }; 510 };
497 511
498 // Assignment expressions.
499
500 class
501 tree_assignment_expression : public tree_expression
502 {
503 public:
504 tree_assignment_expression (int l = -1, int c = -1)
505 : tree_expression (l, c)
506 { etype = tree_expression::assignment; }
507
508 ~tree_assignment_expression (void) { }
509
510 tree_constant eval (int print);
511
512 int is_assignment_expression (void) const
513 { return 1; }
514 };
515
516 // Simple assignment expressions. 512 // Simple assignment expressions.
517 513
518 class 514 class
519 tree_simple_assignment_expression : public tree_assignment_expression 515 tree_simple_assignment_expression : public tree_expression
520 { 516 {
521 public: 517 public:
522 void init (int plhs, int ans_assign) 518 void init (int plhs, int ans_assign)
523 { 519 {
524 etype = tree_expression::assignment; 520 etype = tree_expression::assignment;
529 ans_ass = ans_assign; 525 ans_ass = ans_assign;
530 } 526 }
531 527
532 tree_simple_assignment_expression (int plhs = 0, int ans_assign = 0, 528 tree_simple_assignment_expression (int plhs = 0, int ans_assign = 0,
533 int l = -1, int c = -1) 529 int l = -1, int c = -1)
534 : tree_assignment_expression (l, c) 530 : tree_expression (l, c)
535 { init (plhs, ans_assign); } 531 { init (plhs, ans_assign); }
536 532
537 tree_simple_assignment_expression (tree_identifier *i, 533 tree_simple_assignment_expression (tree_identifier *i,
538 tree_expression *r, 534 tree_expression *r,
539 int plhs = 0, int ans_assign = 0, 535 int plhs = 0, int ans_assign = 0,
540 int l = -1, int c = -1) 536 int l = -1, int c = -1)
541 : tree_assignment_expression (l, c) 537 : tree_expression (l, c)
542 { 538 {
543 init (plhs, ans_assign); 539 init (plhs, ans_assign);
544 lhs = i; 540 lhs = i;
545 rhs = r; 541 rhs = r;
546 } 542 }
547 543
548 tree_simple_assignment_expression (tree_index_expression *idx_expr, 544 tree_simple_assignment_expression (tree_index_expression *idx_expr,
549 tree_expression *r, 545 tree_expression *r,
550 int plhs = 0, int ans_assign = 0, 546 int plhs = 0, int ans_assign = 0,
551 int l = -1, int c = -1) 547 int l = -1, int c = -1)
552 : tree_assignment_expression (l, c) 548 : tree_expression (l, c)
553 { 549 {
554 init (plhs, ans_assign); 550 init (plhs, ans_assign);
555 lhs = idx_expr->ident (); 551 lhs = idx_expr->ident ();
556 index = idx_expr->arg_list (); 552 index = idx_expr->arg_list ();
557 rhs = r; 553 rhs = r;
564 560
565 int is_ans_assign (void) 561 int is_ans_assign (void)
566 { return ans_ass; } 562 { return ans_ass; }
567 563
568 tree_constant eval (int print); 564 tree_constant eval (int print);
565
566 int is_assignment_expression (void) const
567 { return 1; }
569 568
570 void eval_error (void); 569 void eval_error (void);
571 570
572 void print_code (ostream& os); 571 void print_code (ostream& os);
573 572
580 }; 579 };
581 580
582 // Multi-valued assignment expressions. 581 // Multi-valued assignment expressions.
583 582
584 class 583 class
585 tree_multi_assignment_expression : public tree_assignment_expression 584 tree_multi_assignment_expression : public tree_multi_val_ret
586 { 585 {
587 public: 586 public:
588 tree_multi_assignment_expression (int l = -1, int c = -1) 587 tree_multi_assignment_expression (int l = -1, int c = -1)
589 : tree_assignment_expression (l, c) 588 : tree_multi_val_ret (l, c)
590 { 589 {
591 etype = tree_expression::multi_assignment; 590 etype = tree_expression::multi_assignment;
592 lhs = 0; 591 lhs = 0;
593 rhs = 0; 592 rhs = 0;
594 } 593 }
595 594
596 tree_multi_assignment_expression (tree_return_list *lst, 595 tree_multi_assignment_expression (tree_return_list *lst,
597 tree_expression *r, 596 tree_multi_val_ret *r,
598 int l = -1, int c = -1) 597 int l = -1, int c = -1)
599 : tree_assignment_expression (l, c) 598 : tree_multi_val_ret (l, c)
600 { 599 {
601 etype = tree_expression::multi_assignment; 600 etype = tree_expression::multi_assignment;
602 lhs = lst; 601 lhs = lst;
603 rhs = r; 602 rhs = r;
604 } 603 }
607 606
608 tree_constant eval (int print); 607 tree_constant eval (int print);
609 608
610 Octave_object eval (int print, int nargout, const Octave_object& args); 609 Octave_object eval (int print, int nargout, const Octave_object& args);
611 610
611 int is_assignment_expression (void) const
612 { return 1; }
613
612 void eval_error (void); 614 void eval_error (void);
613 615
614 void print_code (ostream& os); 616 void print_code (ostream& os);
615 617
616 private: 618 private:
617 tree_return_list *lhs; 619 tree_return_list *lhs;
618 tree_expression *rhs; 620 tree_multi_val_ret *rhs;
619 }; 621 };
620 622
621 // Colon expressions. 623 // Colon expressions.
622 624
623 class 625 class