Mercurial > octave

comparison libinterp/octave-value/ov.cc @ 21293:350caa6afadf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* ov.cc: Use consistent style for switch statements.
author John W. Eaton <jwe@octave.org>
date Thu, 18 Feb 2016 11:10:05 -0500
parents a83e7a384ee0
children 3d375b0905a0
comparison
equal deleted inserted replaced
21292:c1c601b8e3df 21293:350caa6afadf
111 // Octave's value type. 111 // Octave's value type.
112 112
113 std::string 113 std::string
114 octave_value::unary_op_as_string (unary_op op) 114 octave_value::unary_op_as_string (unary_op op)
115 { 115 {
116 std::string retval;
117
118 switch (op) 116 switch (op)
119 { 117 {
120 case op_not: 118 case op_not:
121 retval = "!"; 119 return "!";
122 break;
123 120
124 case op_uplus: 121 case op_uplus:
125 retval = "+"; 122 return "+";
126 break;
127 123
128 case op_uminus: 124 case op_uminus:
129 retval = "-"; 125 return "-";
130 break;
131 126
132 case op_transpose: 127 case op_transpose:
133 retval = ".'"; 128 return ".'";
134 break;
135 129
136 case op_hermitian: 130 case op_hermitian:
137 retval = "'"; 131 return "'";
138 break;
139 132
140 case op_incr: 133 case op_incr:
141 retval = "++"; 134 return "++";
142 break;
143 135
144 case op_decr: 136 case op_decr:
145 retval = "--"; 137 return "--";
146 break;
147 138
148 default: 139 default:
149 retval = "<unknown>"; 140 return "<unknown>";
150 } 141 }
151
152 return retval;
153 } 142 }
154 143
155 std::string 144 std::string
156 octave_value::unary_op_fcn_name (unary_op op) 145 octave_value::unary_op_fcn_name (unary_op op)
157 { 146 {
158 std::string retval;
159
160 switch (op) 147 switch (op)
161 { 148 {
162 case op_not: 149 case op_not:
163 retval = "not"; 150 return "not";
164 break;
165 151
166 case op_uplus: 152 case op_uplus:
167 retval = "uplus"; 153 return "uplus";
168 break;
169 154
170 case op_uminus: 155 case op_uminus:
171 retval = "uminus"; 156 return "uminus";
172 break;
173 157
174 case op_transpose: 158 case op_transpose:
175 retval = "transpose"; 159 return "transpose";
176 break;
177 160
178 case op_hermitian: 161 case op_hermitian:
179 retval = "ctranspose"; 162 return "ctranspose";
180 break;
181 163
182 default: 164 default:
183 break; 165 return "<unknown>";
184 } 166 }
185
186 return retval;
187 } 167 }
188 168
189 std::string 169 std::string
190 octave_value::binary_op_as_string (binary_op op) 170 octave_value::binary_op_as_string (binary_op op)
191 { 171 {
192 std::string retval;
193
194 switch (op) 172 switch (op)
195 { 173 {
196 case op_add: 174 case op_add:
197 retval = "+"; 175 return "+";
198 break;
199 176
200 case op_sub: 177 case op_sub:
201 retval = "-"; 178 return "-";
202 break;
203 179
204 case op_mul: 180 case op_mul:
205 retval = "*"; 181 return "*";
206 break;
207 182
208 case op_div: 183 case op_div:
209 retval = "/"; 184 return "/";
210 break;
211 185
212 case op_pow: 186 case op_pow:
213 retval = "^"; 187 return "^";
214 break;
215 188
216 case op_ldiv: 189 case op_ldiv:
217 retval = "\\"; 190 return "\\";
218 break;
219 191
220 case op_lshift: 192 case op_lshift:
221 retval = "<<"; 193 return "<<";
222 break;
223 194
224 case op_rshift: 195 case op_rshift:
225 retval = ">>"; 196 return ">>";
226 break;
227 197
228 case op_lt: 198 case op_lt:
229 retval = "<"; 199 return "<";
230 break;
231 200
232 case op_le: 201 case op_le:
233 retval = "<="; 202 return "<=";
234 break;
235 203
236 case op_eq: 204 case op_eq:
237 retval = "=="; 205 return "==";
238 break;
239 206
240 case op_ge: 207 case op_ge:
241 retval = ">="; 208 return ">=";
242 break;
243 209
244 case op_gt: 210 case op_gt:
245 retval = ">"; 211 return ">";
246 break;
247 212
248 case op_ne: 213 case op_ne:
249 retval = "!="; 214 return "!=";
250 break;
251 215
252 case op_el_mul: 216 case op_el_mul:
253 retval = ".*"; 217 return ".*";
254 break;
255 218
256 case op_el_div: 219 case op_el_div:
257 retval = "./"; 220 return "./";
258 break;
259 221
260 case op_el_pow: 222 case op_el_pow:
261 retval = ".^"; 223 return ".^";
262 break;
263 224
264 case op_el_ldiv: 225 case op_el_ldiv:
265 retval = ".\\"; 226 return ".\\";
266 break;
267 227
268 case op_el_and: 228 case op_el_and:
269 retval = "&"; 229 return "&";
270 break;
271 230
272 case op_el_or: 231 case op_el_or:
273 retval = "|"; 232 return "|";
274 break;
275 233
276 case op_struct_ref: 234 case op_struct_ref:
277 retval = "."; 235 return ".";
278 break;
279 236
280 default: 237 default:
281 retval = "<unknown>"; 238 return "<unknown>";
282 } 239 }
283
284 return retval;
285 } 240 }
286 241
287 std::string 242 std::string
288 octave_value::binary_op_fcn_name (binary_op op) 243 octave_value::binary_op_fcn_name (binary_op op)
289 { 244 {
290 std::string retval;
291
292 switch (op) 245 switch (op)
293 { 246 {
294 case op_add: 247 case op_add:
295 retval = "plus"; 248 return "plus";
296 break;
297 249
298 case op_sub: 250 case op_sub:
299 retval = "minus"; 251 return "minus";
300 break;
301 252
302 case op_mul: 253 case op_mul:
303 retval = "mtimes"; 254 return "mtimes";
304 break;
305 255
306 case op_div: 256 case op_div:
307 retval = "mrdivide"; 257 return "mrdivide";
308 break;
309 258
310 case op_pow: 259 case op_pow:
311 retval = "mpower"; 260 return "mpower";
312 break;
313 261
314 case op_ldiv: 262 case op_ldiv:
315 retval = "mldivide"; 263 return "mldivide";
316 break;
317 264
318 case op_lt: 265 case op_lt:
319 retval = "lt"; 266 return "lt";
320 break;
321 267
322 case op_le: 268 case op_le:
323 retval = "le"; 269 return "le";
324 break;
325 270
326 case op_eq: 271 case op_eq:
327 retval = "eq"; 272 return "eq";
328 break;
329 273
330 case op_ge: 274 case op_ge:
331 retval = "ge"; 275 return "ge";
332 break;
333 276
334 case op_gt: 277 case op_gt:
335 retval = "gt"; 278 return "gt";
336 break;
337 279
338 case op_ne: 280 case op_ne:
339 retval = "ne"; 281 return "ne";
340 break;
341 282
342 case op_el_mul: 283 case op_el_mul:
343 retval = "times"; 284 return "times";
344 break;
345 285
346 case op_el_div: 286 case op_el_div:
347 retval = "rdivide"; 287 return "rdivide";
348 break;
349 288
350 case op_el_pow: 289 case op_el_pow:
351 retval = "power"; 290 return "power";
352 break;
353 291
354 case op_el_ldiv: 292 case op_el_ldiv:
355 retval = "ldivide"; 293 return "ldivide";
356 break;
357 294
358 case op_el_and: 295 case op_el_and:
359 retval = "and"; 296 return "and";
360 break;
361 297
362 case op_el_or: 298 case op_el_or:
363 retval = "or"; 299 return "or";
364 break;
365 300
366 default: 301 default:
367 break; 302 return "<unknown>";
368 } 303 }
369
370 return retval;
371 } 304 }
372 305
373 std::string 306 std::string
374 octave_value::binary_op_fcn_name (compound_binary_op op) 307 octave_value::binary_op_fcn_name (compound_binary_op op)
375 { 308 {
376 std::string retval;
377
378 switch (op) 309 switch (op)
379 { 310 {
380 case op_trans_mul: 311 case op_trans_mul:
381 retval = "transtimes"; 312 return "transtimes";
382 break;
383 313
384 case op_mul_trans: 314 case op_mul_trans:
385 retval = "timestrans"; 315 return "timestrans";
386 break;
387 316
388 case op_herm_mul: 317 case op_herm_mul:
389 retval = "hermtimes"; 318 return "hermtimes";
390 break;
391 319
392 case op_mul_herm: 320 case op_mul_herm:
393 retval = "timesherm"; 321 return "timesherm";
394 break;
395 322
396 case op_trans_ldiv: 323 case op_trans_ldiv:
397 retval = "transldiv"; 324 return "transldiv";
398 break;
399 325
400 case op_herm_ldiv: 326 case op_herm_ldiv:
401 retval = "hermldiv"; 327 return "hermldiv";
402 break;
403 328
404 case op_el_and_not: 329 case op_el_and_not:
405 retval = "andnot"; 330 return "andnot";
406 break;
407 331
408 case op_el_or_not: 332 case op_el_or_not:
409 retval = "ornot"; 333 return "ornot";
410 break;
411 334
412 case op_el_not_and: 335 case op_el_not_and:
413 retval = "notand"; 336 return "notand";
414 break;
415 337
416 case op_el_not_or: 338 case op_el_not_or:
417 retval = "notor"; 339 return "notor";
418 break;
419 340
420 default: 341 default:
421 break; 342 return "<unknown>";
422 } 343 }
423
424 return retval;
425 } 344 }
426 345
427 std::string 346 std::string
428 octave_value::assign_op_as_string (assign_op op) 347 octave_value::assign_op_as_string (assign_op op)
429 { 348 {
430 std::string retval;
431
432 switch (op) 349 switch (op)
433 { 350 {
434 case op_asn_eq: 351 case op_asn_eq:
435 retval = "="; 352 return "=";
436 break;
437 353
438 case op_add_eq: 354 case op_add_eq:
439 retval = "+="; 355 return "+=";
440 break;
441 356
442 case op_sub_eq: 357 case op_sub_eq:
443 retval = "-="; 358 return "-=";
444 break;
445 359
446 case op_mul_eq: 360 case op_mul_eq:
447 retval = "*="; 361 return "*=";
448 break;
449 362
450 case op_div_eq: 363 case op_div_eq:
451 retval = "/="; 364 return "/=";
452 break;
453 365
454 case op_ldiv_eq: 366 case op_ldiv_eq:
455 retval = "\\="; 367 return "\\=";
456 break;
457 368
458 case op_pow_eq: 369 case op_pow_eq:
459 retval = "^="; 370 return "^=";
460 break;
461 371
462 case op_lshift_eq: 372 case op_lshift_eq:
463 retval = "<<="; 373 return "<<=";
464 break;
465 374
466 case op_rshift_eq: 375 case op_rshift_eq:
467 retval = ">>="; 376 return ">>=";
468 break;
469 377
470 case op_el_mul_eq: 378 case op_el_mul_eq:
471 retval = ".*="; 379 return ".*=";
472 break;
473 380
474 case op_el_div_eq: 381 case op_el_div_eq:
475 retval = "./="; 382 return "./=";
476 break;
477 383
478 case op_el_ldiv_eq: 384 case op_el_ldiv_eq:
479 retval = ".\\="; 385 return ".\\=";
480 break;
481 386
482 case op_el_pow_eq: 387 case op_el_pow_eq:
483 retval = ".^="; 388 return ".^=";
484 break;
485 389
486 case op_el_and_eq: 390 case op_el_and_eq:
487 retval = "&="; 391 return "&=";
488 break;
489 392
490 case op_el_or_eq: 393 case op_el_or_eq:
491 retval = "|="; 394 return "|=";
492 break;
493 395
494 default: 396 default:
495 retval = "<unknown>"; 397 return "<unknown>";
496 } 398 }
497
498 return retval;
499 } 399 }
500 400
501 octave_value::binary_op 401 octave_value::binary_op
502 octave_value::assign_op_to_binary_op (assign_op op) 402 octave_value::assign_op_to_binary_op (assign_op op)
503 { 403 {
504 switch (op) 404 switch (op)
505 { 405 {
506 case op_add_eq: 406 case op_add_eq:
507 return op_add; 407 return op_add;
408
508 case op_sub_eq: 409 case op_sub_eq:
509 return op_sub; 410 return op_sub;
411
510 case op_mul_eq: 412 case op_mul_eq:
511 return op_mul; 413 return op_mul;
414
512 case op_div_eq: 415 case op_div_eq:
513 return op_div; 416 return op_div;
417
514 case op_ldiv_eq: 418 case op_ldiv_eq:
515 return op_ldiv; 419 return op_ldiv;
420
516 case op_pow_eq: 421 case op_pow_eq:
517 return op_pow; 422 return op_pow;
423
518 case op_lshift_eq: 424 case op_lshift_eq:
519 return op_lshift; 425 return op_lshift;
426
520 case op_rshift_eq: 427 case op_rshift_eq:
521 return op_rshift; 428 return op_rshift;
429
522 case op_el_mul_eq: 430 case op_el_mul_eq:
523 return op_el_mul; 431 return op_el_mul;
432
524 case op_el_div_eq: 433 case op_el_div_eq:
525 return op_el_div; 434 return op_el_div;
435
526 case op_el_ldiv_eq: 436 case op_el_ldiv_eq:
527 return op_el_ldiv; 437 return op_el_ldiv;
438
528 case op_el_pow_eq: 439 case op_el_pow_eq:
529 return op_el_pow; 440 return op_el_pow;
441
530 case op_el_and_eq: 442 case op_el_and_eq:
531 return op_el_and; 443 return op_el_and;
444
532 case op_el_or_eq: 445 case op_el_or_eq:
533 return op_el_or; 446 return op_el_or;
447
534 default: 448 default:
535 return unknown_binary_op; 449 return unknown_binary_op;
536 } 450 }
537
538 } 451 }
539 452
540 octave_value::assign_op 453 octave_value::assign_op
541 octave_value::binary_op_to_assign_op (binary_op op) 454 octave_value::binary_op_to_assign_op (binary_op op)
542 { 455 {
543 assign_op retval;
544
545 switch (op) 456 switch (op)
546 { 457 {
547 case op_add: 458 case op_add:
548 retval = op_add_eq; 459 return op_add_eq;
549 break; 460
550 case op_sub: 461 case op_sub:
551 retval = op_sub_eq; 462 return op_sub_eq;
552 break; 463
553 case op_mul: 464 case op_mul:
554 retval = op_mul_eq; 465 return op_mul_eq;
555 break; 466
556 case op_div: 467 case op_div:
557 retval = op_div_eq; 468 return op_div_eq;
558 break; 469
559 case op_el_mul: 470 case op_el_mul:
560 retval = op_el_mul_eq; 471 return op_el_mul_eq;
561 break; 472
562 case op_el_div: 473 case op_el_div:
563 retval = op_el_div_eq; 474 return op_el_div_eq;
564 break; 475
565 case op_el_and: 476 case op_el_and:
566 retval = op_el_and_eq; 477 return op_el_and_eq;
567 break; 478
568 case op_el_or: 479 case op_el_or:
569 retval = op_el_or_eq; 480 return op_el_or_eq;
570 break; 481
571 default: 482 default:
572 retval = unknown_assign_op; 483 return unknown_assign_op;
573 } 484 }
574
575 return retval;
576 } 485 }
577 486
578 octave_value::octave_value (short int i) 487 octave_value::octave_value (short int i)
579 : rep (new octave_scalar (i)) 488 : rep (new octave_scalar (i))
580 { 489 {
1159 case idx_vector::class_range: 1068 case idx_vector::class_range:
1160 case idx_vector::class_vector: 1069 case idx_vector::class_vector:
1161 rep = new octave_lazy_index (idx); 1070 rep = new octave_lazy_index (idx);
1162 maybe_mutate (); 1071 maybe_mutate ();
1163 return; 1072 return;
1073
1164 default: 1074 default:
1165 break; 1075 break;
1166 } 1076 }
1167 } 1077 }
1168 1078
1171 switch (idx_class) 1081 switch (idx_class)
1172 { 1082 {
1173 case idx_vector::class_colon: 1083 case idx_vector::class_colon:
1174 rep = new octave_magic_colon (); 1084 rep = new octave_magic_colon ();
1175 break; 1085 break;
1086
1176 case idx_vector::class_range: 1087 case idx_vector::class_range:
1177 rep = new octave_range (range, idx); 1088 rep = new octave_range (range, idx);
1178 break; 1089 break;
1090
1179 case idx_vector::class_scalar: 1091 case idx_vector::class_scalar:
1180 rep = new octave_scalar (scalar); 1092 rep = new octave_scalar (scalar);
1181 break; 1093 break;
1094
1182 case idx_vector::class_vector: 1095 case idx_vector::class_vector:
1183 rep = new octave_matrix (array, idx); 1096 rep = new octave_matrix (array, idx);
1184 break; 1097 break;
1098
1185 case idx_vector::class_mask: 1099 case idx_vector::class_mask:
1186 rep = new octave_bool_matrix (mask, idx); 1100 rep = new octave_bool_matrix (mask, idx);
1187 break; 1101 break;
1102
1188 default: 1103 default:
1189 assert (false); 1104 panic_impossible ();
1190 break; 1105 break;
1191 } 1106 }
1192 1107
1193 // FIXME: needed? 1108 // FIXME: needed?
1194 maybe_mutate (); 1109 maybe_mutate ();
2199 2114
2200 static octave_value 2115 static octave_value
2201 decompose_binary_op (octave_value::compound_binary_op op, 2116 decompose_binary_op (octave_value::compound_binary_op op,
2202 const octave_value& v1, const octave_value& v2) 2117 const octave_value& v1, const octave_value& v2)
2203 { 2118 {
2204 octave_value retval;
2205
2206 switch (op) 2119 switch (op)
2207 { 2120 {
2208 case octave_value::op_trans_mul: 2121 case octave_value::op_trans_mul:
2209 retval = do_binary_op (octave_value::op_mul, 2122 return do_binary_op (octave_value::op_mul,
2210 do_unary_op (octave_value::op_transpose, v1), 2123 do_unary_op (octave_value::op_transpose, v1), v2);
2211 v2); 2124
2212 break;
2213 case octave_value::op_mul_trans: 2125 case octave_value::op_mul_trans:
2214 retval = do_binary_op (octave_value::op_mul, 2126 return do_binary_op (octave_value::op_mul,
2215 v1, 2127 v1, do_unary_op (octave_value::op_transpose, v2));
2216 do_unary_op (octave_value::op_transpose, v2)); 2128
2217 break;
2218 case octave_value::op_herm_mul: 2129 case octave_value::op_herm_mul:
2219 retval = do_binary_op (octave_value::op_mul, 2130 return do_binary_op (octave_value::op_mul,
2220 do_unary_op (octave_value::op_hermitian, v1), 2131 do_unary_op (octave_value::op_hermitian, v1), v2);
2221 v2); 2132
2222 break;
2223 case octave_value::op_mul_herm: 2133 case octave_value::op_mul_herm:
2224 retval = do_binary_op (octave_value::op_mul, 2134 return do_binary_op (octave_value::op_mul,
2225 v1, 2135 v1, do_unary_op (octave_value::op_hermitian, v2));
2226 do_unary_op (octave_value::op_hermitian, v2)); 2136
2227 break;
2228 case octave_value::op_trans_ldiv: 2137 case octave_value::op_trans_ldiv:
2229 retval = do_binary_op (octave_value::op_ldiv, 2138 return do_binary_op (octave_value::op_ldiv,
2230 do_unary_op (octave_value::op_transpose, v1), 2139 do_unary_op (octave_value::op_transpose, v1), v2);
2231 v2); 2140
2232 break;
2233 case octave_value::op_herm_ldiv: 2141 case octave_value::op_herm_ldiv:
2234 retval = do_binary_op (octave_value::op_ldiv, 2142 return do_binary_op (octave_value::op_ldiv,
2235 do_unary_op (octave_value::op_hermitian, v1), 2143 do_unary_op (octave_value::op_hermitian, v1), v2);
2236 v2); 2144
2237 break;
2238 case octave_value::op_el_not_and: 2145 case octave_value::op_el_not_and:
2239 retval = do_binary_op (octave_value::op_el_and, 2146 return do_binary_op (octave_value::op_el_and,
2240 do_unary_op (octave_value::op_not, v1), 2147 do_unary_op (octave_value::op_not, v1), v2);
2241 v2); 2148
2242 break;
2243 case octave_value::op_el_not_or: 2149 case octave_value::op_el_not_or:
2244 retval = do_binary_op (octave_value::op_el_or, 2150 return do_binary_op (octave_value::op_el_or,
2245 do_unary_op (octave_value::op_not, v1), 2151 do_unary_op (octave_value::op_not, v1), v2);
2246 v2); 2152
2247 break;
2248 case octave_value::op_el_and_not: 2153 case octave_value::op_el_and_not:
2249 retval = do_binary_op (octave_value::op_el_and, 2154 return do_binary_op (octave_value::op_el_and,
2250 v1, 2155 v1, do_unary_op (octave_value::op_not, v2));
2251 do_unary_op (octave_value::op_not, v2)); 2156
2252 break;
2253 case octave_value::op_el_or_not: 2157 case octave_value::op_el_or_not:
2254 retval = do_binary_op (octave_value::op_el_or, 2158 return do_binary_op (octave_value::op_el_or,
2255 v1, 2159 v1, do_unary_op (octave_value::op_not, v2));
2256 do_unary_op (octave_value::op_not, v2)); 2160
2257 break;
2258 default: 2161 default:
2259 error ("invalid compound operator"); 2162 error ("invalid compound operator");
2260 break; 2163 }
2261 }
2262
2263 return retval;
2264 } 2164 }
2265 2165
2266 octave_value 2166 octave_value
2267 do_binary_op (octave_value::compound_binary_op op, 2167 do_binary_op (octave_value::compound_binary_op op,
2268 const octave_value& v1, const octave_value& v2) 2168 const octave_value& v1, const octave_value& v2)
2671 } 2571 }
2672 2572
2673 octave_value::assign_op 2573 octave_value::assign_op
2674 octave_value::unary_op_to_assign_op (unary_op op) 2574 octave_value::unary_op_to_assign_op (unary_op op)
2675 { 2575 {
2676 assign_op binop = unknown_assign_op;
2677
2678 switch (op) 2576 switch (op)
2679 { 2577 {
2680 case op_incr: 2578 case op_incr:
2681 binop = op_add_eq; 2579 return op_add_eq;
2682 break;
2683 2580
2684 case op_decr: 2581 case op_decr:
2685 binop = op_sub_eq; 2582 return op_sub_eq;
2686 break;
2687 2583
2688 default: 2584 default:
2689 { 2585 {
2690 std::string on = unary_op_as_string (op); 2586 std::string on = unary_op_as_string (op);
2691 error ("operator %s: no assign operator found", on.c_str ()); 2587 error ("operator %s: no assign operator found", on.c_str ());
2692 } 2588 }
2693 } 2589 }
2694
2695 return binop;
2696 } 2590 }
2697 2591
2698 octave_value::binary_op 2592 octave_value::binary_op
2699 octave_value::op_eq_to_binary_op (assign_op op) 2593 octave_value::op_eq_to_binary_op (assign_op op)
2700 { 2594 {
2701 binary_op binop = unknown_binary_op;
2702
2703 switch (op) 2595 switch (op)
2704 { 2596 {
2705 case op_add_eq: 2597 case op_add_eq:
2706 binop = op_add; 2598 return op_add;
2707 break;
2708 2599
2709 case op_sub_eq: 2600 case op_sub_eq:
2710 binop = op_sub; 2601 return op_sub;
2711 break;
2712 2602
2713 case op_mul_eq: 2603 case op_mul_eq:
2714 binop = op_mul; 2604 return op_mul;
2715 break;
2716 2605
2717 case op_div_eq: 2606 case op_div_eq:
2718 binop = op_div; 2607 return op_div;
2719 break;
2720 2608
2721 case op_ldiv_eq: 2609 case op_ldiv_eq:
2722 binop = op_ldiv; 2610 return op_ldiv;
2723 break;
2724 2611
2725 case op_pow_eq: 2612 case op_pow_eq:
2726 binop = op_pow; 2613 return op_pow;
2727 break;
2728 2614
2729 case op_lshift_eq: 2615 case op_lshift_eq:
2730 binop = op_lshift; 2616 return op_lshift;
2731 break;
2732 2617
2733 case op_rshift_eq: 2618 case op_rshift_eq:
2734 binop = op_rshift; 2619 return op_rshift;
2735 break;
2736 2620
2737 case op_el_mul_eq: 2621 case op_el_mul_eq:
2738 binop = op_el_mul; 2622 return op_el_mul;
2739 break;
2740 2623
2741 case op_el_div_eq: 2624 case op_el_div_eq:
2742 binop = op_el_div; 2625 return op_el_div;
2743 break;
2744 2626
2745 case op_el_ldiv_eq: 2627 case op_el_ldiv_eq:
2746 binop = op_el_ldiv; 2628 return op_el_ldiv;
2747 break;
2748 2629
2749 case op_el_pow_eq: 2630 case op_el_pow_eq:
2750 binop = op_el_pow; 2631 return op_el_pow;
2751 break;
2752 2632
2753 case op_el_and_eq: 2633 case op_el_and_eq:
2754 binop = op_el_and; 2634 return op_el_and;
2755 break;
2756 2635
2757 case op_el_or_eq: 2636 case op_el_or_eq:
2758 binop = op_el_or; 2637 return op_el_or;
2759 break;
2760 2638
2761 default: 2639 default:
2762 { 2640 {
2763 std::string on = assign_op_as_string (op); 2641 std::string on = assign_op_as_string (op);
2764 error ("operator %s: no binary operator found", on.c_str ()); 2642 error ("operator %s: no binary operator found", on.c_str ());
2765 } 2643 }
2766 } 2644 }
2767
2768 return binop;
2769 } 2645 }
2770 2646
2771 octave_value 2647 octave_value
2772 octave_value::empty_conv (const std::string& type, const octave_value& rhs) 2648 octave_value::empty_conv (const std::string& type, const octave_value& rhs)
2773 { 2649 {
2774 octave_value retval;
2775
2776 if (type.length () > 0) 2650 if (type.length () > 0)
2777 { 2651 {
2778 switch (type[0]) 2652 switch (type[0])
2779 { 2653 {
2780 case '(': 2654 case '(':
2781 { 2655 if (type.length () > 1 && type[1] == '.')
2782 if (type.length () > 1 && type[1] == '.') 2656 return octave_map ();
2783 retval = octave_map (); 2657 else
2784 else 2658 return = octave_value (rhs.empty_clone ());
2785 retval = octave_value (rhs.empty_clone ());
2786 }
2787 break;
2788 2659
2789 case '{': 2660 case '{':
2790 retval = Cell (); 2661 return Cell ();
2791 break;
2792 2662
2793 case '.': 2663 case '.':
2794 retval = octave_scalar_map (); 2664 return octave_scalar_map ();
2795 break;
2796 2665
2797 default: 2666 default:
2798 panic_impossible (); 2667 panic_impossible ();
2799 } 2668 }
2800 } 2669 }
2801 else 2670 else
2802 retval = octave_value (rhs.empty_clone ()); 2671 return octave_value (rhs.empty_clone ());
2803
2804 return retval;
2805 } 2672 }
2806 2673
2807 void 2674 void
2808 install_types (void) 2675 install_types (void)
2809 { 2676 {