Mercurial > octave-nkf

comparison src/pt-unop.cc @ 3203:bc61b0e8d60e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 1998-10-30 20:26:27 by jwe]
author jwe
date Fri, 30 Oct 1998 20:26:31 +0000
parents 20f5cec4f11c
children 096ad38d7ab5
comparison
equal deleted inserted replaced
3202:44d82b369c78 3203:bc61b0e8d60e
33 #include "oct-lvalue.h" 33 #include "oct-lvalue.h"
34 #include "ov.h" 34 #include "ov.h"
35 #include "pt-unop.h" 35 #include "pt-unop.h"
36 #include "pt-walk.h" 36 #include "pt-walk.h"
37 37
38 // Unary expressions.
39
40 string
41 tree_unary_expression::oper (void) const
42 {
43 return octave_value::unary_op_as_string (etype);
44 }
45
38 // Prefix expressions. 46 // Prefix expressions.
39 47
40 octave_value_list 48 octave_value_list
41 tree_prefix_expression::rvalue (int nargout) 49 tree_prefix_expression::rvalue (int nargout)
42 { 50 {
59 if (error_state) 67 if (error_state)
60 return retval; 68 return retval;
61 69
62 if (op) 70 if (op)
63 { 71 {
64 if (etype == unot || etype == uminus) 72 if (etype == octave_value::incr || etype == octave_value::decr)
73 {
74 octave_lvalue ref = op->lvalue ();
75
76 if (error_state)
77 eval_error ();
78 else if (ref.is_defined ())
79 {
80 ref.do_unary_op (etype);
81
82 retval = ref.value ();
83 }
84 else
85 eval_error ();
86 }
87 else
65 { 88 {
66 octave_value val = op->rvalue (); 89 octave_value val = op->rvalue ();
67 90
68 if (! error_state) 91 if (error_state)
69 { 92 eval_error ();
70 if (val.is_defined ()) 93 else if (val.is_defined ())
94 {
95 retval = ::do_unary_op (etype, val);
96
97 if (error_state)
71 { 98 {
72 if (etype == unot) 99 retval = octave_value ();
73 retval = val.not (); 100 eval_error ();
74 else
75 retval = val.uminus ();
76 } 101 }
77 else 102 }
78 error ("argument to prefix operator `%s' undefined", 103 else
79 oper () . c_str ()); 104 eval_error ();
80 } 105 }
81 }
82 else if (etype == increment || etype == decrement)
83 {
84 octave_lvalue ref = op->lvalue ();
85
86 if (! error_state)
87 {
88 if (ref.is_defined ())
89 {
90 if (etype == increment)
91 ref.increment ();
92 else
93 ref.decrement ();
94
95 retval = ref.value ();
96 }
97 else
98 error ("argument to prefix operator `%s' undefined",
99 oper () . c_str ());
100 }
101 }
102 else
103 error ("prefix operator %d not implemented", etype);
104 } 106 }
105 107
106 return retval; 108 return retval;
107 } 109 }
108 110
110 tree_prefix_expression::eval_error (void) 112 tree_prefix_expression::eval_error (void)
111 { 113 {
112 if (error_state > 0) 114 if (error_state > 0)
113 ::error ("evaluating prefix operator `%s' near line %d, column %d", 115 ::error ("evaluating prefix operator `%s' near line %d, column %d",
114 oper () . c_str (), line (), column ()); 116 oper () . c_str (), line (), column ());
115 }
116
117 string
118 tree_prefix_expression::oper (void) const
119 {
120 string retval = "<unknown>";
121
122 switch (etype)
123 {
124 case unot:
125 retval = "!";
126 break;
127
128 case uminus:
129 retval = "-";
130 break;
131
132 case increment:
133 retval = "++";
134 break;
135
136 case decrement:
137 retval = "--";
138 break;
139
140 default:
141 break;
142 }
143
144 return retval;
145 } 117 }
146 118
147 void 119 void
148 tree_prefix_expression::accept (tree_walker& tw) 120 tree_prefix_expression::accept (tree_walker& tw)
149 { 121 {
174 if (error_state) 146 if (error_state)
175 return retval; 147 return retval;
176 148
177 if (op) 149 if (op)
178 { 150 {
179 if (etype == transpose || etype == hermitian) 151 if (etype == octave_value::incr || etype == octave_value::decr)
152 {
153 octave_lvalue ref = op->lvalue ();
154
155 if (error_state)
156 eval_error ();
157 else if (ref.is_defined ())
158 {
159 retval = ref.value ();
160
161 ref.do_unary_op (etype);
162 }
163 else
164 eval_error ();
165 }
166 else
180 { 167 {
181 octave_value val = op->rvalue (); 168 octave_value val = op->rvalue ();
182 169
183 if (! error_state) 170 if (error_state)
184 { 171 eval_error ();
185 if (val.is_defined ()) 172 else if (val.is_defined ())
173 {
174 retval = ::do_unary_op (etype, val);
175
176 if (error_state)
186 { 177 {
187 if (etype == transpose) 178 retval = octave_value ();
188 retval = val.transpose (); 179 eval_error ();
189 else
190 retval = val.hermitian ();
191 } 180 }
192 else 181 }
193 error ("argument to postfix operator `%s' undefined", 182 else
194 oper () . c_str ()); 183 eval_error ();
195 } 184 }
196 }
197 else if (etype == increment || etype == decrement)
198 {
199 octave_lvalue ref = op->lvalue ();
200
201 if (! error_state)
202 {
203 if (ref.is_defined ())
204 {
205 retval = ref.value ();
206
207 if (etype == increment)
208 ref.increment ();
209 else
210 ref.decrement ();
211 }
212 else
213 error ("argument to postfix operator `%s' undefined",
214 oper () . c_str ());
215 }
216 }
217 else
218 error ("postfix operator %d not implemented", etype);
219 } 185 }
186 else
187 eval_error ();
220 188
221 return retval; 189 return retval;
222 } 190 }
223 191
224 void 192 void
225 tree_postfix_expression::eval_error (void) 193 tree_postfix_expression::eval_error (void)
226 { 194 {
227 if (error_state > 0) 195 if (error_state > 0)
228 ::error ("evaluating postfix operator `%s' near line %d, column %d", 196 ::error ("evaluating postfix operator `%s' near line %d, column %d",
229 oper () . c_str (), line (), column ()); 197 oper () . c_str (), line (), column ());
230 }
231
232 string
233 tree_postfix_expression::oper (void) const
234 {
235 string retval = "<unknown>";
236
237 switch (etype)
238 {
239 case transpose:
240 retval = ".'";
241 break;
242
243 case hermitian:
244 retval = "'";
245 break;
246
247 case increment:
248 retval = "++";
249 break;
250
251 case decrement:
252 retval = "--";
253 break;
254
255 default:
256 break;
257 }
258
259 return retval;
260 } 198 }
261 199
262 void 200 void
263 tree_postfix_expression::accept (tree_walker& tw) 201 tree_postfix_expression::accept (tree_walker& tw)
264 { 202 {