Mercurial > hg > octave-lyh

comparison src/pt-unop.cc @ 10315:57a59eae83cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
untabify src C++ source files
author John W. Eaton <jwe@octave.org>
date Thu, 11 Feb 2010 12:41:46 -0500
parents cd96d29c5efa
children d1194069e58c
comparison
equal deleted inserted replaced
10314:07ebe522dac2 10315:57a59eae83cc
48 { 48 {
49 octave_value_list retval; 49 octave_value_list retval;
50 50
51 if (nargout > 1) 51 if (nargout > 1)
52 error ("prefix operator `%s': invalid number of output arguments", 52 error ("prefix operator `%s': invalid number of output arguments",
53 oper () . c_str ()); 53 oper () . c_str ());
54 else 54 else
55 retval = rvalue1 (nargout); 55 retval = rvalue1 (nargout);
56 56
57 return retval; 57 return retval;
58 } 58 }
66 return retval; 66 return retval;
67 67
68 if (op) 68 if (op)
69 { 69 {
70 if (etype == octave_value::op_incr || etype == octave_value::op_decr) 70 if (etype == octave_value::op_incr || etype == octave_value::op_decr)
71 { 71 {
72 op->rvalue1 (); 72 op->rvalue1 ();
73 73
74 if (! error_state) 74 if (! error_state)
75 { 75 {
76 octave_lvalue ref = op->lvalue (); 76 octave_lvalue ref = op->lvalue ();
77 77
78 if (! error_state && ref.is_defined ()) 78 if (! error_state && ref.is_defined ())
79 { 79 {
80 ref.do_unary_op (etype); 80 ref.do_unary_op (etype);
81 81
82 retval = ref.value (); 82 retval = ref.value ();
83 } 83 }
84 } 84 }
85 } 85 }
86 else 86 else
87 { 87 {
88 octave_value val = op->rvalue1 (); 88 octave_value val = op->rvalue1 ();
89 89
90 if (! error_state && val.is_defined ()) 90 if (! error_state && val.is_defined ())
91 { 91 {
92 // Attempt to do the operation in-place if it is unshared 92 // Attempt to do the operation in-place if it is unshared
93 // (a temporary expression). 93 // (a temporary expression).
94 if (val.get_count () == 1) 94 if (val.get_count () == 1)
95 retval = val.do_non_const_unary_op (etype); 95 retval = val.do_non_const_unary_op (etype);
96 else 96 else
97 retval = ::do_unary_op (etype, val); 97 retval = ::do_unary_op (etype, val);
98 98
99 if (error_state) 99 if (error_state)
100 retval = octave_value (); 100 retval = octave_value ();
101 } 101 }
102 } 102 }
103 } 103 }
104 104
105 return retval; 105 return retval;
106 } 106 }
107 107
108 tree_expression * 108 tree_expression *
109 tree_prefix_expression::dup (symbol_table::scope_id scope, 109 tree_prefix_expression::dup (symbol_table::scope_id scope,
110 symbol_table::context_id context) const 110 symbol_table::context_id context) const
111 { 111 {
112 tree_prefix_expression *new_pe 112 tree_prefix_expression *new_pe
113 = new tree_prefix_expression (op ? op->dup (scope, context) : 0, 113 = new tree_prefix_expression (op ? op->dup (scope, context) : 0,
114 line (), column (), etype); 114 line (), column (), etype);
115 115
116 new_pe->copy_base (*this); 116 new_pe->copy_base (*this);
117 117
118 return new_pe; 118 return new_pe;
119 } 119 }
131 { 131 {
132 octave_value_list retval; 132 octave_value_list retval;
133 133
134 if (nargout > 1) 134 if (nargout > 1)
135 error ("postfix operator `%s': invalid number of output arguments", 135 error ("postfix operator `%s': invalid number of output arguments",
136 oper () . c_str ()); 136 oper () . c_str ());
137 else 137 else
138 retval = rvalue1 (nargout); 138 retval = rvalue1 (nargout);
139 139
140 return retval; 140 return retval;
141 } 141 }
149 return retval; 149 return retval;
150 150
151 if (op) 151 if (op)
152 { 152 {
153 if (etype == octave_value::op_incr || etype == octave_value::op_decr) 153 if (etype == octave_value::op_incr || etype == octave_value::op_decr)
154 { 154 {
155 op->rvalue1 (); 155 op->rvalue1 ();
156 156
157 if (! error_state) 157 if (! error_state)
158 { 158 {
159 octave_lvalue ref = op->lvalue (); 159 octave_lvalue ref = op->lvalue ();
160 160
161 if (! error_state && ref.is_defined ()) 161 if (! error_state && ref.is_defined ())
162 { 162 {
163 retval = ref.value (); 163 retval = ref.value ();
164 164
165 ref.do_unary_op (etype); 165 ref.do_unary_op (etype);
166 } 166 }
167 } 167 }
168 } 168 }
169 else 169 else
170 { 170 {
171 octave_value val = op->rvalue1 (); 171 octave_value val = op->rvalue1 ();
172 172
173 if (! error_state && val.is_defined ()) 173 if (! error_state && val.is_defined ())
174 { 174 {
175 retval = ::do_unary_op (etype, val); 175 retval = ::do_unary_op (etype, val);
176 176
177 if (error_state) 177 if (error_state)
178 retval = octave_value (); 178 retval = octave_value ();
179 } 179 }
180 } 180 }
181 } 181 }
182 182
183 return retval; 183 return retval;
184 } 184 }
185 185
186 tree_expression * 186 tree_expression *
187 tree_postfix_expression::dup (symbol_table::scope_id scope, 187 tree_postfix_expression::dup (symbol_table::scope_id scope,
188 symbol_table::context_id context) const 188 symbol_table::context_id context) const
189 { 189 {
190 tree_postfix_expression *new_pe 190 tree_postfix_expression *new_pe
191 = new tree_postfix_expression (op ? op->dup (scope, context) : 0, 191 = new tree_postfix_expression (op ? op->dup (scope, context) : 0,
192 line (), column (), etype); 192 line (), column (), etype);
193 193
194 new_pe->copy_base (*this); 194 new_pe->copy_base (*this);
195 195
196 return new_pe; 196 return new_pe;
197 } 197 }