Mercurial > octave
comparison src/pt-unop.cc @ 2980:cd5ad3fd8049
[project @ 1997-05-16 01:12:13 by jwe]
author | jwe |
---|---|
date | Fri, 16 May 1997 01:13:19 +0000 |
parents | |
children | 20f5cec4f11c |
comparison
equal
deleted
inserted
replaced
2979:a3556d2adec9 | 2980:cd5ad3fd8049 |
---|---|
1 /* | |
2 | |
3 Copyright (C) 1996, 1997 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 2, or (at your option) any | |
10 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, write to the Free | |
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
20 | |
21 */ | |
22 | |
23 #if defined (__GNUG__) | |
24 #pragma implementation | |
25 #endif | |
26 | |
27 #ifdef HAVE_CONFIG_H | |
28 #include <config.h> | |
29 #endif | |
30 | |
31 #include "error.h" | |
32 #include "oct-obj.h" | |
33 #include "oct-lvalue.h" | |
34 #include "ov.h" | |
35 #include "pt-unop.h" | |
36 #include "pt-pr-code.h" | |
37 #include "pt-walk.h" | |
38 | |
39 // Prefix expressions. | |
40 | |
41 octave_value_list | |
42 tree_prefix_expression::rvalue (int nargout) | |
43 { | |
44 octave_value_list retval; | |
45 | |
46 if (nargout > 1) | |
47 error ("prefix operator `%s': invalid number of output arguments", | |
48 oper () . c_str ()); | |
49 else | |
50 retval = rvalue (); | |
51 | |
52 return retval; | |
53 } | |
54 | |
55 octave_value | |
56 tree_prefix_expression::rvalue (void) | |
57 { | |
58 octave_value retval; | |
59 | |
60 if (error_state) | |
61 return retval; | |
62 | |
63 if (op) | |
64 { | |
65 if (etype == unot || etype == uminus) | |
66 { | |
67 octave_value val = op->rvalue (); | |
68 | |
69 if (! error_state) | |
70 { | |
71 if (val.is_defined ()) | |
72 { | |
73 if (etype == unot) | |
74 retval = val.not (); | |
75 else | |
76 retval = val.uminus (); | |
77 } | |
78 else | |
79 error ("argument to prefix operator `%s' undefined", | |
80 oper () . c_str ()); | |
81 } | |
82 } | |
83 else if (etype == increment || etype == decrement) | |
84 { | |
85 octave_lvalue ref = op->lvalue (); | |
86 | |
87 if (! error_state) | |
88 { | |
89 if (ref.is_defined ()) | |
90 { | |
91 if (etype == increment) | |
92 ref.increment (); | |
93 else | |
94 ref.decrement (); | |
95 | |
96 retval = ref.value (); | |
97 } | |
98 else | |
99 error ("argument to prefix operator `%s' undefined", | |
100 oper () . c_str ()); | |
101 } | |
102 } | |
103 else | |
104 error ("prefix operator %d not implemented", etype); | |
105 } | |
106 | |
107 return retval; | |
108 } | |
109 | |
110 void | |
111 tree_prefix_expression::eval_error (void) | |
112 { | |
113 if (error_state > 0) | |
114 ::error ("evaluating prefix operator `%s' near line %d, column %d", | |
115 oper () . c_str (), line (), column ()); | |
116 } | |
117 | |
118 string | |
119 tree_prefix_expression::oper (void) const | |
120 { | |
121 string retval = "<unknown>"; | |
122 | |
123 switch (etype) | |
124 { | |
125 case unot: | |
126 retval = "!"; | |
127 break; | |
128 | |
129 case uminus: | |
130 retval = "-"; | |
131 break; | |
132 | |
133 case increment: | |
134 retval = "++"; | |
135 break; | |
136 | |
137 case decrement: | |
138 retval = "--"; | |
139 break; | |
140 | |
141 default: | |
142 break; | |
143 } | |
144 | |
145 return retval; | |
146 } | |
147 | |
148 void | |
149 tree_prefix_expression::accept (tree_walker& tw) | |
150 { | |
151 tw.visit_prefix_expression (*this); | |
152 } | |
153 | |
154 // Postfix expressions. | |
155 | |
156 octave_value_list | |
157 tree_postfix_expression::rvalue (int nargout) | |
158 { | |
159 octave_value_list retval; | |
160 | |
161 if (nargout > 1) | |
162 error ("postfix operator `%s': invalid number of output arguments", | |
163 oper () . c_str ()); | |
164 else | |
165 retval = rvalue (); | |
166 | |
167 return retval; | |
168 } | |
169 | |
170 octave_value | |
171 tree_postfix_expression::rvalue (void) | |
172 { | |
173 octave_value retval; | |
174 | |
175 if (error_state) | |
176 return retval; | |
177 | |
178 if (op) | |
179 { | |
180 if (etype == transpose || etype == hermitian) | |
181 { | |
182 octave_value val = op->rvalue (); | |
183 | |
184 if (! error_state) | |
185 { | |
186 if (val.is_defined ()) | |
187 { | |
188 if (etype == transpose) | |
189 retval = val.transpose (); | |
190 else | |
191 retval = val.hermitian (); | |
192 } | |
193 else | |
194 error ("argument to postfix operator `%s' undefined", | |
195 oper () . c_str ()); | |
196 } | |
197 } | |
198 else if (etype == increment || etype == decrement) | |
199 { | |
200 octave_lvalue ref = op->lvalue (); | |
201 | |
202 if (! error_state) | |
203 { | |
204 if (ref.is_defined ()) | |
205 { | |
206 retval = ref.value (); | |
207 | |
208 if (etype == increment) | |
209 ref.increment (); | |
210 else | |
211 ref.decrement (); | |
212 } | |
213 else | |
214 error ("argument to postfix operator `%s' undefined", | |
215 oper () . c_str ()); | |
216 } | |
217 } | |
218 else | |
219 error ("postfix operator %d not implemented", etype); | |
220 } | |
221 | |
222 return retval; | |
223 } | |
224 | |
225 void | |
226 tree_postfix_expression::eval_error (void) | |
227 { | |
228 if (error_state > 0) | |
229 ::error ("evaluating postfix operator `%s' near line %d, column %d", | |
230 oper () . c_str (), line (), column ()); | |
231 } | |
232 | |
233 string | |
234 tree_postfix_expression::oper (void) const | |
235 { | |
236 string retval = "<unknown>"; | |
237 | |
238 switch (etype) | |
239 { | |
240 case transpose: | |
241 retval = ".'"; | |
242 break; | |
243 | |
244 case hermitian: | |
245 retval = "'"; | |
246 break; | |
247 | |
248 case increment: | |
249 retval = "++"; | |
250 break; | |
251 | |
252 case decrement: | |
253 retval = "--"; | |
254 break; | |
255 | |
256 default: | |
257 break; | |
258 } | |
259 | |
260 return retval; | |
261 } | |
262 | |
263 void | |
264 tree_postfix_expression::accept (tree_walker& tw) | |
265 { | |
266 tw.visit_postfix_expression (*this); | |
267 } | |
268 | |
269 /* | |
270 ;;; Local Variables: *** | |
271 ;;; mode: C++ *** | |
272 ;;; End: *** | |
273 */ |