Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 30fdc8d841c9d24ac5f3d452b6ece84ee0ac991c / . / lldb / source / Core / Scalar.cpp
blob: 56590b8d69e6236e71be4ad0662bdc3d6ec83dde [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame^]1//===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Core/Scalar.h"
11
12#include <math.h>
13
14#include "lldb/Core/Args.h"
15#include "lldb/Core/Error.h"
16#include "lldb/Core/Stream.h"
17#include "lldb/Core/DataExtractor.h"
18
19using namespace lldb;
20using namespace lldb_private;
21
22//----------------------------------------------------------------------
23// Promote to max type currently follows the ANSI C rule for type
24// promotion in expressions.
25//----------------------------------------------------------------------
26static Scalar::Type
27PromoteToMaxType
28(
29 const Scalar& lhs, // The const left hand side object
30 const Scalar& rhs, // The const right hand side object
31 Scalar& temp_value, // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
32 const Scalar* &promoted_lhs_ptr, // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
33 const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
34)
35{
36 Scalar result;
37 // Initialize the promoted values for both the right and left hand side values
38 // to be the objects themselves. If no promotion is needed (both right and left
39 // have the same type), then the temp_value will not get used.
40 promoted_lhs_ptr = &lhs;
41 promoted_rhs_ptr = &rhs;
42 // Extract the types of both the right and left hand side values
43 Scalar::Type lhs_type = lhs.GetType();
44 Scalar::Type rhs_type = rhs.GetType();
45
46 if (lhs_type > rhs_type)
47 {
48 // Right hand side need to be promoted
49 temp_value = rhs; // Copy right hand side into the temp value
50 if (temp_value.Promote(lhs_type)) // Promote it
51 promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
52 }
53 else if (lhs_type < rhs_type)
54 {
55 // Left hand side need to be promoted
56 temp_value = lhs; // Copy left hand side value into the temp value
57 if (temp_value.Promote(rhs_type)) // Promote it
58 promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
59 }
60
61 // Make sure our type promotion worked as exptected
62 if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
63 return promoted_lhs_ptr->GetType(); // Return the resulting max type
64
65 // Return the void type (zero) if we fail to promote either of the values.
66 return Scalar::e_void;
67}
68
69
70//----------------------------------------------------------------------
71// Scalar constructor
72//----------------------------------------------------------------------
73Scalar::Scalar() :
74 m_type(e_void),
75 m_data()
76{
77}
78
79//----------------------------------------------------------------------
80// Scalar copy constructor
81//----------------------------------------------------------------------
82Scalar::Scalar(const Scalar& rhs) :
83 m_type(rhs.m_type),
84 m_data(rhs.m_data) // TODO: verify that for C++ this will correctly copy the union??
85{
86}
87
88//Scalar::Scalar(const RegisterValue& reg) :
89// m_type(e_void),
90// m_data()
91//{
92// switch (reg.info.encoding)
93// {
94// case eEncodingUint: // unsigned integer
95// switch (reg.info.byte_size)
96// {
97// case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
98// case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
99// case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
100// case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
101// break;
102// }
103// break;
104//
105// case eEncodingSint: // signed integer
106// switch (reg.info.byte_size)
107// {
108// case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
109// case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
110// case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
111// case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
112// break;
113// }
114// break;
115//
116// case eEncodingIEEE754: // float
117// switch (reg.info.byte_size)
118// {
119// case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
120// case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
121// break;
122// }
123// break;
124// case eEncodingVector: // vector registers
125// break;
126// }
127//}
128
129bool
130Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
131{
132 size_t byte_size = GetByteSize();
133 if (byte_size > 0)
134 {
135 if (limit_byte_size < byte_size)
136 {
137 if (eByteOrderHost == eByteOrderLittle)
138 {
139 // On little endian systems if we want fewer bytes from the
140 // current type we just specify fewer bytes since the LSByte
141 // is first...
142 data.SetData((uint8_t*)&m_data, limit_byte_size, eByteOrderHost);
143 }
144 else if (eByteOrderHost == eByteOrderBig)
145 {
146 // On big endian systems if we want fewer bytes from the
147 // current type have to advance our initial byte pointer and
148 // trim down the number of bytes since the MSByte is first
149 data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, eByteOrderHost);
150 }
151 }
152 else
153 {
154 // We want all of the data
155 data.SetData((uint8_t*)&m_data, byte_size, eByteOrderHost);
156 }
157 return true;
158 }
159 data.Clear();
160 return false;
161}
162
163size_t
164Scalar::GetByteSize() const
165{
166 switch (m_type)
167 {
168 default:
169 case e_void:
170 break;
171 case e_sint: return sizeof(m_data.sint);
172 case e_uint: return sizeof(m_data.uint);
173 case e_slong: return sizeof(m_data.slong);
174 case e_ulong: return sizeof(m_data.ulong);
175 case e_slonglong: return sizeof(m_data.slonglong);
176 case e_ulonglong: return sizeof(m_data.ulonglong);
177 case e_float: return sizeof(m_data.flt);
178 case e_double: return sizeof(m_data.dbl);
179 case e_long_double: return sizeof(m_data.ldbl);
180 }
181 return 0;
182}
183
184bool
185Scalar::IsZero() const
186{
187 switch (m_type)
188 {
189 default:
190 case e_void:
191 break;
192 case e_sint: return m_data.sint == 0;
193 case e_uint: return m_data.uint == 0;
194 case e_slong: return m_data.slong == 0;
195 case e_ulong: return m_data.ulong == 0;
196 case e_slonglong: return m_data.slonglong == 0;
197 case e_ulonglong: return m_data.ulonglong == 0;
198 case e_float: return m_data.flt == 0.0f;
199 case e_double: return m_data.dbl == 0.0;
200 case e_long_double: return m_data.ldbl == 0.0;
201 }
202 return false;
203}
204
205void
206Scalar::GetValue (Stream *s, bool show_type) const
207{
208 if (show_type)
209 s->Printf("(%s) ", GetTypeAsCString());
210
211 switch (m_type)
212 {
213 case e_void:
214 default:
215 break;
216 case e_sint: s->Printf("%i", m_data.sint); break;
217 case e_uint: s->Printf("0x%8.8x", m_data.uint); break;
218 case e_slong: s->Printf("%li", m_data.slong); break;
219 case e_ulong: s->Printf("0x%8.8lx", m_data.ulong); break;
220 case e_slonglong: s->Printf("%lli", m_data.slonglong); break;
221 case e_ulonglong: s->Printf("0x%16.16llx", m_data.ulonglong); break;
222 case e_float: s->Printf("%f", m_data.flt); break;
223 case e_double: s->Printf("%g", m_data.dbl); break;
224 case e_long_double: s->Printf("%Lg", m_data.ldbl); break;
225 }
226}
227
228const char *
229Scalar::GetTypeAsCString() const
230{
231 switch (m_type)
232 {
233 default:
234 break;
235 case e_void: return "void";
236 case e_sint: return "int";
237 case e_uint: return "unsigned int";
238 case e_slong: return "long";
239 case e_ulong: return "unsigned long";
240 case e_slonglong: return "long long";
241 case e_ulonglong: return "unsigned long long";
242 case e_float: return "float";
243 case e_double: return "double";
244 case e_long_double: return "long double";
245 }
246 return "<invalid Scalar type>";
247}
248
249
250
251//----------------------------------------------------------------------
252// Scalar copy constructor
253//----------------------------------------------------------------------
254Scalar&
255Scalar::operator=(const Scalar& rhs)
256{
257 if (this != &rhs)
258 {
259 m_type = rhs.m_type;
260 ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
261 }
262 return *this;
263}
264
265Scalar&
266Scalar::operator= (const int v)
267{
268 m_type = e_sint;
269 m_data.sint = v;
270 return *this;
271}
272
273
274Scalar&
275Scalar::operator= (unsigned int v)
276{
277 m_type = e_uint;
278 m_data.uint = v;
279 return *this;
280}
281
282Scalar&
283Scalar::operator= (long v)
284{
285 m_type = e_slong;
286 m_data.slong = v;
287 return *this;
288}
289
290Scalar&
291Scalar::operator= (unsigned long v)
292{
293 m_type = e_ulong;
294 m_data.ulong = v;
295 return *this;
296}
297
298Scalar&
299Scalar::operator= (long long v)
300{
301 m_type = e_slonglong;
302 m_data.slonglong = v;
303 return *this;
304}
305
306Scalar&
307Scalar::operator= (unsigned long long v)
308{
309 m_type = e_ulonglong;
310 m_data.ulonglong = v;
311 return *this;
312}
313
314Scalar&
315Scalar::operator= (float v)
316{
317 m_type = e_float;
318 m_data.flt = v;
319 return *this;
320}
321
322Scalar&
323Scalar::operator= (double v)
324{
325 m_type = e_double;
326 m_data.dbl = v;
327 return *this;
328}
329
330Scalar&
331Scalar::operator= (long double v)
332{
333 m_type = e_long_double;
334 m_data.ldbl = v;
335 return *this;
336}
337
338//----------------------------------------------------------------------
339// Destructor
340//----------------------------------------------------------------------
341Scalar::~Scalar()
342{
343}
344
345bool
346Scalar::Promote(Scalar::Type type)
347{
348 bool success = false;
349 switch (m_type)
350 {
351 case e_void:
352 break;
353
354 case e_sint:
355 switch (type)
356 {
357 default:
358 case e_void: break;
359 case e_sint: success = true; break;
360 case e_uint: m_data.uint = m_data.sint; success = true; break;
361 case e_slong: m_data.slong = m_data.sint; success = true; break;
362 case e_ulong: m_data.ulong = m_data.sint; success = true; break;
363 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
364 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
365 case e_float: m_data.flt = m_data.sint; success = true; break;
366 case e_double: m_data.dbl = m_data.sint; success = true; break;
367 case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
368 }
369 break;
370
371 case e_uint:
372 switch (type)
373 {
374 default:
375 case e_void:
376 case e_sint: break;
377 case e_uint: success = true; break;
378 case e_slong: m_data.slong = m_data.uint; success = true; break;
379 case e_ulong: m_data.ulong = m_data.uint; success = true; break;
380 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
381 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
382 case e_float: m_data.flt = m_data.uint; success = true; break;
383 case e_double: m_data.dbl = m_data.uint; success = true; break;
384 case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
385 }
386 break;
387
388 case e_slong:
389 switch (type)
390 {
391 default:
392 case e_void:
393 case e_sint:
394 case e_uint: break;
395 case e_slong: success = true; break;
396 case e_ulong: m_data.ulong = m_data.slong; success = true; break;
397 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
398 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
399 case e_float: m_data.flt = m_data.slong; success = true; break;
400 case e_double: m_data.dbl = m_data.slong; success = true; break;
401 case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
402 }
403 break;
404
405 case e_ulong:
406 switch (type)
407 {
408 default:
409 case e_void:
410 case e_sint:
411 case e_uint:
412 case e_slong: break;
413 case e_ulong: success = true; break;
414 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
415 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
416 case e_float: m_data.flt = m_data.ulong; success = true; break;
417 case e_double: m_data.dbl = m_data.ulong; success = true; break;
418 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
419 }
420 break;
421
422 case e_slonglong:
423 switch (type)
424 {
425 default:
426 case e_void:
427 case e_sint:
428 case e_uint:
429 case e_slong:
430 case e_ulong: break;
431 case e_slonglong: success = true; break;
432 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
433 case e_float: m_data.flt = m_data.slonglong; success = true; break;
434 case e_double: m_data.dbl = m_data.slonglong; success = true; break;
435 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
436 }
437 break;
438
439 case e_ulonglong:
440 switch (type)
441 {
442 default:
443 case e_void:
444 case e_sint:
445 case e_uint:
446 case e_slong:
447 case e_ulong:
448 case e_slonglong: break;
449 case e_ulonglong: success = true; break;
450 case e_float: m_data.flt = m_data.ulonglong; success = true; break;
451 case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
452 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
453 }
454 break;
455
456 case e_float:
457 switch (type)
458 {
459 default:
460 case e_void:
461 case e_sint:
462 case e_uint:
463 case e_slong:
464 case e_ulong:
465 case e_slonglong:
466 case e_ulonglong: break;
467 case e_float: success = true; break;
468 case e_double: m_data.dbl = m_data.flt; success = true; break;
469 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
470 }
471 break;
472
473 case e_double:
474 switch (type)
475 {
476 default:
477 case e_void:
478 case e_sint:
479 case e_uint:
480 case e_slong:
481 case e_ulong:
482 case e_slonglong:
483 case e_ulonglong:
484 case e_float: break;
485 case e_double: success = true; break;
486 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
487 }
488 break;
489
490 case e_long_double:
491 switch (type)
492 {
493 default:
494 case e_void:
495 case e_sint:
496 case e_uint:
497 case e_slong:
498 case e_ulong:
499 case e_slonglong:
500 case e_ulonglong:
501 case e_float:
502 case e_double: break;
503 case e_long_double: success = true; break;
504 }
505 break;
506 }
507
508 if (success)
509 m_type = type;
510 return success;
511}
512
513const char *
514Scalar::GetValueTypeAsCString (Scalar::Type type)
515{
516 switch (type)
517 {
518 default: break;
519 case e_void: return "void";
520 case e_sint: return "int";
521 case e_uint: return "unsigned int";
522 case e_slong: return "long";
523 case e_ulong: return "unsigned long";
524 case e_slonglong: return "long long";
525 case e_ulonglong: return "unsigned long long";
526 case e_float: return "float";
527 case e_double: return "double";
528 case e_long_double: return "long double";
529 }
530 return "???";
531}
532
533
534Scalar::Type
535Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
536{
537 if (byte_size <= sizeof(int))
538 return e_sint;
539 if (byte_size <= sizeof(long))
540 return e_slong;
541 if (byte_size <= sizeof(long long))
542 return e_slonglong;
543 return e_void;
544}
545
546Scalar::Type
547Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
548{
549 if (byte_size <= sizeof(unsigned int))
550 return e_uint;
551 if (byte_size <= sizeof(unsigned long))
552 return e_ulong;
553 if (byte_size <= sizeof(unsigned long long))
554 return e_ulonglong;
555 return e_void;
556}
557
558Scalar::Type
559Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
560{
561 if (byte_size == sizeof(float))
562 return e_float;
563 if (byte_size == sizeof(double))
564 return e_double;
565 if (byte_size == sizeof(long double))
566 return e_long_double;
567 return e_void;
568}
569
570bool
571Scalar::Cast(Scalar::Type type)
572{
573 bool success = false;
574 switch (m_type)
575 {
576 case e_void:
577 break;
578
579 case e_sint:
580 switch (type)
581 {
582 default:
583 case e_void: break;
584 case e_sint: success = true; break;
585 case e_uint: m_data.uint = m_data.sint; success = true; break;
586 case e_slong: m_data.slong = m_data.sint; success = true; break;
587 case e_ulong: m_data.ulong = m_data.sint; success = true; break;
588 case e_slonglong: m_data.slonglong = m_data.sint; success = true; break;
589 case e_ulonglong: m_data.ulonglong = m_data.sint; success = true; break;
590 case e_float: m_data.flt = m_data.sint; success = true; break;
591 case e_double: m_data.dbl = m_data.sint; success = true; break;
592 case e_long_double: m_data.ldbl = m_data.sint; success = true; break;
593 }
594 break;
595
596 case e_uint:
597 switch (type)
598 {
599 default:
600 case e_void:
601 case e_sint: m_data.sint = m_data.uint; success = true; break;
602 case e_uint: success = true; break;
603 case e_slong: m_data.slong = m_data.uint; success = true; break;
604 case e_ulong: m_data.ulong = m_data.uint; success = true; break;
605 case e_slonglong: m_data.slonglong = m_data.uint; success = true; break;
606 case e_ulonglong: m_data.ulonglong = m_data.uint; success = true; break;
607 case e_float: m_data.flt = m_data.uint; success = true; break;
608 case e_double: m_data.dbl = m_data.uint; success = true; break;
609 case e_long_double: m_data.ldbl = m_data.uint; success = true; break;
610 }
611 break;
612
613 case e_slong:
614 switch (type)
615 {
616 default:
617 case e_void:
618 case e_sint: m_data.sint = m_data.slong; success = true; break;
619 case e_uint: m_data.uint = m_data.slong; success = true; break;
620 case e_slong: success = true; break;
621 case e_ulong: m_data.ulong = m_data.slong; success = true; break;
622 case e_slonglong: m_data.slonglong = m_data.slong; success = true; break;
623 case e_ulonglong: m_data.ulonglong = m_data.slong; success = true; break;
624 case e_float: m_data.flt = m_data.slong; success = true; break;
625 case e_double: m_data.dbl = m_data.slong; success = true; break;
626 case e_long_double: m_data.ldbl = m_data.slong; success = true; break;
627 }
628 break;
629
630 case e_ulong:
631 switch (type)
632 {
633 default:
634 case e_void:
635 case e_sint: m_data.sint = m_data.ulong; success = true; break;
636 case e_uint: m_data.uint = m_data.ulong; success = true; break;
637 case e_slong: m_data.slong = m_data.ulong; success = true; break;
638 case e_ulong: success = true; break;
639 case e_slonglong: m_data.slonglong = m_data.ulong; success = true; break;
640 case e_ulonglong: m_data.ulonglong = m_data.ulong; success = true; break;
641 case e_float: m_data.flt = m_data.ulong; success = true; break;
642 case e_double: m_data.dbl = m_data.ulong; success = true; break;
643 case e_long_double: m_data.ldbl = m_data.ulong; success = true; break;
644 }
645 break;
646
647 case e_slonglong:
648 switch (type)
649 {
650 default:
651 case e_void:
652 case e_sint: m_data.sint = m_data.slonglong; success = true; break;
653 case e_uint: m_data.uint = m_data.slonglong; success = true; break;
654 case e_slong: m_data.slong = m_data.slonglong; success = true; break;
655 case e_ulong: m_data.ulong = m_data.slonglong; success = true; break;
656 case e_slonglong: success = true; break;
657 case e_ulonglong: m_data.ulonglong = m_data.slonglong; success = true; break;
658 case e_float: m_data.flt = m_data.slonglong; success = true; break;
659 case e_double: m_data.dbl = m_data.slonglong; success = true; break;
660 case e_long_double: m_data.ldbl = m_data.slonglong; success = true; break;
661 }
662 break;
663
664 case e_ulonglong:
665 switch (type)
666 {
667 default:
668 case e_void:
669 case e_sint: m_data.sint = m_data.ulonglong; success = true; break;
670 case e_uint: m_data.uint = m_data.ulonglong; success = true; break;
671 case e_slong: m_data.slong = m_data.ulonglong; success = true; break;
672 case e_ulong: m_data.ulong = m_data.ulonglong; success = true; break;
673 case e_slonglong: m_data.slonglong = m_data.ulonglong; success = true; break;
674 case e_ulonglong: success = true; break;
675 case e_float: m_data.flt = m_data.ulonglong; success = true; break;
676 case e_double: m_data.dbl = m_data.ulonglong; success = true; break;
677 case e_long_double: m_data.ldbl = m_data.ulonglong; success = true; break;
678 }
679 break;
680
681 case e_float:
682 switch (type)
683 {
684 default:
685 case e_void:
686 case e_sint: m_data.sint = m_data.flt; success = true; break;
687 case e_uint: m_data.uint = m_data.flt; success = true; break;
688 case e_slong: m_data.slong = m_data.flt; success = true; break;
689 case e_ulong: m_data.ulong = m_data.flt; success = true; break;
690 case e_slonglong: m_data.slonglong = m_data.flt; success = true; break;
691 case e_ulonglong: m_data.ulonglong = m_data.flt; success = true; break;
692 case e_float: success = true; break;
693 case e_double: m_data.dbl = m_data.flt; success = true; break;
694 case e_long_double: m_data.ldbl = m_data.flt; success = true; break;
695 }
696 break;
697
698 case e_double:
699 switch (type)
700 {
701 default:
702 case e_void:
703 case e_sint: m_data.sint = m_data.dbl; success = true; break;
704 case e_uint: m_data.uint = m_data.dbl; success = true; break;
705 case e_slong: m_data.slong = m_data.dbl; success = true; break;
706 case e_ulong: m_data.ulong = m_data.dbl; success = true; break;
707 case e_slonglong: m_data.slonglong = m_data.dbl; success = true; break;
708 case e_ulonglong: m_data.ulonglong = m_data.dbl; success = true; break;
709 case e_float: m_data.flt = m_data.dbl; success = true; break;
710 case e_double: success = true; break;
711 case e_long_double: m_data.ldbl = m_data.dbl; success = true; break;
712 }
713 break;
714
715 case e_long_double:
716 switch (type)
717 {
718 default:
719 case e_void:
720 case e_sint: m_data.sint = m_data.ldbl; success = true; break;
721 case e_uint: m_data.uint = m_data.ldbl; success = true; break;
722 case e_slong: m_data.slong = m_data.ldbl; success = true; break;
723 case e_ulong: m_data.ulong = m_data.ldbl; success = true; break;
724 case e_slonglong: m_data.slonglong = m_data.ldbl; success = true; break;
725 case e_ulonglong: m_data.ulonglong = m_data.ldbl; success = true; break;
726 case e_float: m_data.flt = m_data.ldbl; success = true; break;
727 case e_double: m_data.dbl = m_data.ldbl; success = true; break;
728 case e_long_double: success = true; break;
729 }
730 break;
731 }
732
733 if (success)
734 m_type = type;
735 return success;
736}
737
738int
739Scalar::SInt(int fail_value) const
740{
741 switch (m_type)
742 {
743 default:
744 case e_void: break;
745 case e_sint: return m_data.sint;
746 case e_uint: return (int)m_data.uint;
747 case e_slong: return (int)m_data.slong;
748 case e_ulong: return (int)m_data.ulong;
749 case e_slonglong: return (int)m_data.slonglong;
750 case e_ulonglong: return (int)m_data.ulonglong;
751 case e_float: return (int)m_data.flt;
752 case e_double: return (int)m_data.dbl;
753 case e_long_double: return (int)m_data.ldbl;
754 }
755 return fail_value;
756}
757
758unsigned int
759Scalar::UInt(unsigned int fail_value) const
760{
761 switch (m_type)
762 {
763 default:
764 case e_void: break;
765 case e_sint: return (unsigned int)m_data.sint;
766 case e_uint: return (unsigned int)m_data.uint;
767 case e_slong: return (unsigned int)m_data.slong;
768 case e_ulong: return (unsigned int)m_data.ulong;
769 case e_slonglong: return (unsigned int)m_data.slonglong;
770 case e_ulonglong: return (unsigned int)m_data.ulonglong;
771 case e_float: return (unsigned int)m_data.flt;
772 case e_double: return (unsigned int)m_data.dbl;
773 case e_long_double: return (unsigned int)m_data.ldbl;
774 }
775 return fail_value;
776}
777
778
779long
780Scalar::SLong(long fail_value) const
781{
782 switch (m_type)
783 {
784 default:
785 case e_void: break;
786 case e_sint: return (long)m_data.sint;
787 case e_uint: return (long)m_data.uint;
788 case e_slong: return (long)m_data.slong;
789 case e_ulong: return (long)m_data.ulong;
790 case e_slonglong: return (long)m_data.slonglong;
791 case e_ulonglong: return (long)m_data.ulonglong;
792 case e_float: return (long)m_data.flt;
793 case e_double: return (long)m_data.dbl;
794 case e_long_double: return (long)m_data.ldbl;
795 }
796 return fail_value;
797}
798
799
800
801unsigned long
802Scalar::ULong(unsigned long fail_value) const
803{
804 switch (m_type)
805 {
806 default:
807 case e_void: break;
808 case e_sint: return (unsigned long)m_data.sint;
809 case e_uint: return (unsigned long)m_data.uint;
810 case e_slong: return (unsigned long)m_data.slong;
811 case e_ulong: return (unsigned long)m_data.ulong;
812 case e_slonglong: return (unsigned long)m_data.slonglong;
813 case e_ulonglong: return (unsigned long)m_data.ulonglong;
814 case e_float: return (unsigned long)m_data.flt;
815 case e_double: return (unsigned long)m_data.dbl;
816 case e_long_double: return (unsigned long)m_data.ldbl;
817 }
818 return fail_value;
819}
820
821uint64_t
822Scalar::GetRawBits64(uint64_t fail_value) const
823{
824 switch (m_type)
825 {
826 default:
827 case e_void:
828 break;
829
830 case e_sint:
831 case e_uint:
832 return m_data.uint;
833
834 case e_slong:
835 case e_ulong:
836 return m_data.ulong;
837
838 case e_slonglong:
839 case e_ulonglong:
840 return m_data.ulonglong;
841
842 case e_float:
843 if (sizeof(m_data.flt) == sizeof(int))
844 return m_data.uint;
845 else if (sizeof(m_data.flt) == sizeof(unsigned long))
846 return m_data.ulong;
847 else if (sizeof(m_data.flt) == sizeof(unsigned long long))
848 return m_data.ulonglong;
849 break;
850
851 case e_double:
852 if (sizeof(m_data.dbl) == sizeof(int))
853 return m_data.uint;
854 else if (sizeof(m_data.dbl) == sizeof(unsigned long))
855 return m_data.ulong;
856 else if (sizeof(m_data.dbl) == sizeof(unsigned long long))
857 return m_data.ulonglong;
858 break;
859
860 case e_long_double:
861 if (sizeof(m_data.ldbl) == sizeof(int))
862 return m_data.uint;
863 else if (sizeof(m_data.ldbl) == sizeof(unsigned long))
864 return m_data.ulong;
865 else if (sizeof(m_data.ldbl) == sizeof(unsigned long long))
866 return m_data.ulonglong;
867 break;
868 }
869 return fail_value;
870}
871
872
873
874long long
875Scalar::SLongLong(long long fail_value) const
876{
877 switch (m_type)
878 {
879 default:
880 case e_void: break;
881 case e_sint: return (long long)m_data.sint;
882 case e_uint: return (long long)m_data.uint;
883 case e_slong: return (long long)m_data.slong;
884 case e_ulong: return (long long)m_data.ulong;
885 case e_slonglong: return (long long)m_data.slonglong;
886 case e_ulonglong: return (long long)m_data.ulonglong;
887 case e_float: return (long long)m_data.flt;
888 case e_double: return (long long)m_data.dbl;
889 case e_long_double: return (long long)m_data.ldbl;
890 }
891 return fail_value;
892}
893
894
895unsigned long long
896Scalar::ULongLong(unsigned long long fail_value) const
897{
898 switch (m_type)
899 {
900 default:
901 case e_void: break;
902 case e_sint: return (unsigned long long)m_data.sint;
903 case e_uint: return (unsigned long long)m_data.uint;
904 case e_slong: return (unsigned long long)m_data.slong;
905 case e_ulong: return (unsigned long long)m_data.ulong;
906 case e_slonglong: return (unsigned long long)m_data.slonglong;
907 case e_ulonglong: return (unsigned long long)m_data.ulonglong;
908 case e_float: return (unsigned long long)m_data.flt;
909 case e_double: return (unsigned long long)m_data.dbl;
910 case e_long_double: return (unsigned long long)m_data.ldbl;
911 }
912 return fail_value;
913}
914
915
916float
917Scalar::Float(float fail_value) const
918{
919 switch (m_type)
920 {
921 default:
922 case e_void: break;
923 case e_sint: return (float)m_data.sint;
924 case e_uint: return (float)m_data.uint;
925 case e_slong: return (float)m_data.slong;
926 case e_ulong: return (float)m_data.ulong;
927 case e_slonglong: return (float)m_data.slonglong;
928 case e_ulonglong: return (float)m_data.ulonglong;
929 case e_float: return (float)m_data.flt;
930 case e_double: return (float)m_data.dbl;
931 case e_long_double: return (float)m_data.ldbl;
932 }
933 return fail_value;
934}
935
936
937double
938Scalar::Double(double fail_value) const
939{
940 switch (m_type)
941 {
942 default:
943 case e_void: break;
944 case e_sint: return (double)m_data.sint;
945 case e_uint: return (double)m_data.uint;
946 case e_slong: return (double)m_data.slong;
947 case e_ulong: return (double)m_data.ulong;
948 case e_slonglong: return (double)m_data.slonglong;
949 case e_ulonglong: return (double)m_data.ulonglong;
950 case e_float: return (double)m_data.flt;
951 case e_double: return (double)m_data.dbl;
952 case e_long_double: return (double)m_data.ldbl;
953 }
954 return fail_value;
955}
956
957
958long double
959Scalar::LongDouble(long double fail_value) const
960{
961 switch (m_type)
962 {
963 default:
964 case e_void: break;
965 case e_sint: return (long double)m_data.sint;
966 case e_uint: return (long double)m_data.uint;
967 case e_slong: return (long double)m_data.slong;
968 case e_ulong: return (long double)m_data.ulong;
969 case e_slonglong: return (long double)m_data.slonglong;
970 case e_ulonglong: return (long double)m_data.ulonglong;
971 case e_float: return (long double)m_data.flt;
972 case e_double: return (long double)m_data.dbl;
973 case e_long_double: return (long double)m_data.ldbl;
974 }
975 return fail_value;
976}
977
978
979Scalar&
980Scalar::operator+= (const Scalar& rhs)
981{
982 Scalar temp_value;
983 const Scalar* a;
984 const Scalar* b;
985 if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
986 {
987 switch (m_type)
988 {
989 default:
990 case e_void: break;
991 case e_sint: m_data.sint = a->m_data.sint + b->m_data.sint; break;
992 case e_uint: m_data.uint = a->m_data.uint + b->m_data.uint; break;
993 case e_slong: m_data.slong = a->m_data.slong + b->m_data.slong; break;
994 case e_ulong: m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
995 case e_slonglong: m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
996 case e_ulonglong: m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
997 case e_float: m_data.flt = a->m_data.flt + b->m_data.flt; break;
998 case e_double: m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
999 case e_long_double: m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
1000 }
1001 }
1002 return *this;
1003}
1004
1005Scalar&
1006Scalar::operator<<= (const Scalar& rhs)
1007{
1008 switch (m_type)
1009 {
1010 default:
1011 case e_void:
1012 case e_float:
1013 case e_double:
1014 case e_long_double:
1015 m_type = e_void;
1016 break;
1017
1018 case e_sint:
1019 switch (rhs.m_type)
1020 {
1021 default:
1022 case e_void:
1023 case e_float:
1024 case e_double:
1025 case e_long_double:
1026 m_type = e_void;
1027 break;
1028 case e_sint: m_data.sint <<= rhs.m_data.sint; break;
1029 case e_uint: m_data.sint <<= rhs.m_data.uint; break;
1030 case e_slong: m_data.sint <<= rhs.m_data.slong; break;
1031 case e_ulong: m_data.sint <<= rhs.m_data.ulong; break;
1032 case e_slonglong: m_data.sint <<= rhs.m_data.slonglong; break;
1033 case e_ulonglong: m_data.sint <<= rhs.m_data.ulonglong; break;
1034 }
1035 break;
1036
1037 case e_uint:
1038 switch (rhs.m_type)
1039 {
1040 default:
1041 case e_void:
1042 case e_float:
1043 case e_double:
1044 case e_long_double:
1045 m_type = e_void;
1046 break;
1047 case e_sint: m_data.uint <<= rhs.m_data.sint; break;
1048 case e_uint: m_data.uint <<= rhs.m_data.uint; break;
1049 case e_slong: m_data.uint <<= rhs.m_data.slong; break;
1050 case e_ulong: m_data.uint <<= rhs.m_data.ulong; break;
1051 case e_slonglong: m_data.uint <<= rhs.m_data.slonglong; break;
1052 case e_ulonglong: m_data.uint <<= rhs.m_data.ulonglong; break;
1053 }
1054 break;
1055
1056 case e_slong:
1057 switch (rhs.m_type)
1058 {
1059 default:
1060 case e_void:
1061 case e_float:
1062 case e_double:
1063 case e_long_double:
1064 m_type = e_void;
1065 break;
1066 case e_sint: m_data.slong <<= rhs.m_data.sint; break;
1067 case e_uint: m_data.slong <<= rhs.m_data.uint; break;
1068 case e_slong: m_data.slong <<= rhs.m_data.slong; break;
1069 case e_ulong: m_data.slong <<= rhs.m_data.ulong; break;
1070 case e_slonglong: m_data.slong <<= rhs.m_data.slonglong; break;
1071 case e_ulonglong: m_data.slong <<= rhs.m_data.ulonglong; break;
1072 }
1073 break;
1074
1075 case e_ulong:
1076 switch (rhs.m_type)
1077 {
1078 default:
1079 case e_void:
1080 case e_float:
1081 case e_double:
1082 case e_long_double:
1083 m_type = e_void;
1084 break;
1085 case e_sint: m_data.ulong <<= rhs.m_data.sint; break;
1086 case e_uint: m_data.ulong <<= rhs.m_data.uint; break;
1087 case e_slong: m_data.ulong <<= rhs.m_data.slong; break;
1088 case e_ulong: m_data.ulong <<= rhs.m_data.ulong; break;
1089 case e_slonglong: m_data.ulong <<= rhs.m_data.slonglong; break;
1090 case e_ulonglong: m_data.ulong <<= rhs.m_data.ulonglong; break;
1091 }
1092 break;
1093 case e_slonglong:
1094 switch (rhs.m_type)
1095 {
1096 default:
1097 case e_void:
1098 case e_float:
1099 case e_double:
1100 case e_long_double:
1101 m_type = e_void;
1102 break;
1103 case e_sint: m_data.slonglong <<= rhs.m_data.sint; break;
1104 case e_uint: m_data.slonglong <<= rhs.m_data.uint; break;
1105 case e_slong: m_data.slonglong <<= rhs.m_data.slong; break;
1106 case e_ulong: m_data.slonglong <<= rhs.m_data.ulong; break;
1107 case e_slonglong: m_data.slonglong <<= rhs.m_data.slonglong; break;
1108 case e_ulonglong: m_data.slonglong <<= rhs.m_data.ulonglong; break;
1109 }
1110 break;
1111
1112 case e_ulonglong:
1113 switch (rhs.m_type)
1114 {
1115 default:
1116 case e_void:
1117 case e_float:
1118 case e_double:
1119 case e_long_double:
1120 m_type = e_void;
1121 break;
1122 case e_sint: m_data.ulonglong <<= rhs.m_data.sint; break;
1123 case e_uint: m_data.ulonglong <<= rhs.m_data.uint; break;
1124 case e_slong: m_data.ulonglong <<= rhs.m_data.slong; break;
1125 case e_ulong: m_data.ulonglong <<= rhs.m_data.ulong; break;
1126 case e_slonglong: m_data.ulonglong <<= rhs.m_data.slonglong; break;
1127 case e_ulonglong: m_data.ulonglong <<= rhs.m_data.ulonglong; break;
1128 }
1129 break;
1130 }
1131 return *this;
1132}
1133
1134bool
1135Scalar::ShiftRightLogical(const Scalar& rhs)
1136{
1137 switch (m_type)
1138 {
1139 default:
1140 case e_void:
1141 case e_float:
1142 case e_double:
1143 case e_long_double:
1144 m_type = e_void;
1145 break;
1146
1147 case e_sint:
1148 case e_uint:
1149 switch (rhs.m_type)
1150 {
1151 default:
1152 case e_void:
1153 case e_float:
1154 case e_double:
1155 case e_long_double:
1156 m_type = e_void;
1157 break;
1158 case e_sint: m_data.uint >>= rhs.m_data.sint; break;
1159 case e_uint: m_data.uint >>= rhs.m_data.uint; break;
1160 case e_slong: m_data.uint >>= rhs.m_data.slong; break;
1161 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
1162 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
1163 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
1164 }
1165 break;
1166
1167 case e_slong:
1168 case e_ulong:
1169 switch (rhs.m_type)
1170 {
1171 default:
1172 case e_void:
1173 case e_float:
1174 case e_double:
1175 case e_long_double:
1176 m_type = e_void;
1177 break;
1178 case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
1179 case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
1180 case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
1181 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
1182 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
1183 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
1184 }
1185 break;
1186
1187 case e_slonglong:
1188 case e_ulonglong:
1189 switch (rhs.m_type)
1190 {
1191 default:
1192 case e_void:
1193 case e_float:
1194 case e_double:
1195 case e_long_double:
1196 m_type = e_void;
1197 break;
1198 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
1199 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
1200 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
1201 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
1202 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
1203 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
1204 }
1205 break;
1206 }
1207 return m_type != e_void;
1208}
1209
1210
1211Scalar&
1212Scalar::operator>>= (const Scalar& rhs)
1213{
1214 switch (m_type)
1215 {
1216 default:
1217 case e_void:
1218 case e_float:
1219 case e_double:
1220 case e_long_double:
1221 m_type = e_void;
1222 break;
1223
1224 case e_sint:
1225 switch (rhs.m_type)
1226 {
1227 default:
1228 case e_void:
1229 case e_float:
1230 case e_double:
1231 case e_long_double:
1232 m_type = e_void;
1233 break;
1234 case e_sint: m_data.sint >>= rhs.m_data.sint; break;
1235 case e_uint: m_data.sint >>= rhs.m_data.uint; break;
1236 case e_slong: m_data.sint >>= rhs.m_data.slong; break;
1237 case e_ulong: m_data.sint >>= rhs.m_data.ulong; break;
1238 case e_slonglong: m_data.sint >>= rhs.m_data.slonglong; break;
1239 case e_ulonglong: m_data.sint >>= rhs.m_data.ulonglong; break;
1240 }
1241 break;
1242
1243 case e_uint:
1244 switch (rhs.m_type)
1245 {
1246 default:
1247 case e_void:
1248 case e_float:
1249 case e_double:
1250 case e_long_double:
1251 m_type = e_void;
1252 break;
1253 case e_sint: m_data.uint >>= rhs.m_data.sint; break;
1254 case e_uint: m_data.uint >>= rhs.m_data.uint; break;
1255 case e_slong: m_data.uint >>= rhs.m_data.slong; break;
1256 case e_ulong: m_data.uint >>= rhs.m_data.ulong; break;
1257 case e_slonglong: m_data.uint >>= rhs.m_data.slonglong; break;
1258 case e_ulonglong: m_data.uint >>= rhs.m_data.ulonglong; break;
1259 }
1260 break;
1261
1262 case e_slong:
1263 switch (rhs.m_type)
1264 {
1265 default:
1266 case e_void:
1267 case e_float:
1268 case e_double:
1269 case e_long_double:
1270 m_type = e_void;
1271 break;
1272 case e_sint: m_data.slong >>= rhs.m_data.sint; break;
1273 case e_uint: m_data.slong >>= rhs.m_data.uint; break;
1274 case e_slong: m_data.slong >>= rhs.m_data.slong; break;
1275 case e_ulong: m_data.slong >>= rhs.m_data.ulong; break;
1276 case e_slonglong: m_data.slong >>= rhs.m_data.slonglong; break;
1277 case e_ulonglong: m_data.slong >>= rhs.m_data.ulonglong; break;
1278 }
1279 break;
1280
1281 case e_ulong:
1282 switch (rhs.m_type)
1283 {
1284 default:
1285 case e_void:
1286 case e_float:
1287 case e_double:
1288 case e_long_double:
1289 m_type = e_void;
1290 break;
1291 case e_sint: m_data.ulong >>= rhs.m_data.sint; break;
1292 case e_uint: m_data.ulong >>= rhs.m_data.uint; break;
1293 case e_slong: m_data.ulong >>= rhs.m_data.slong; break;
1294 case e_ulong: m_data.ulong >>= rhs.m_data.ulong; break;
1295 case e_slonglong: m_data.ulong >>= rhs.m_data.slonglong; break;
1296 case e_ulonglong: m_data.ulong >>= rhs.m_data.ulonglong; break;
1297 }
1298 break;
1299 case e_slonglong:
1300 switch (rhs.m_type)
1301 {
1302 default:
1303 case e_void:
1304 case e_float:
1305 case e_double:
1306 case e_long_double:
1307 m_type = e_void;
1308 break;
1309 case e_sint: m_data.slonglong >>= rhs.m_data.sint; break;
1310 case e_uint: m_data.slonglong >>= rhs.m_data.uint; break;
1311 case e_slong: m_data.slonglong >>= rhs.m_data.slong; break;
1312 case e_ulong: m_data.slonglong >>= rhs.m_data.ulong; break;
1313 case e_slonglong: m_data.slonglong >>= rhs.m_data.slonglong; break;
1314 case e_ulonglong: m_data.slonglong >>= rhs.m_data.ulonglong; break;
1315 }
1316 break;
1317
1318 case e_ulonglong:
1319 switch (rhs.m_type)
1320 {
1321 default:
1322 case e_void:
1323 case e_float:
1324 case e_double:
1325 case e_long_double:
1326 m_type = e_void;
1327 break;
1328 case e_sint: m_data.ulonglong >>= rhs.m_data.sint; break;
1329 case e_uint: m_data.ulonglong >>= rhs.m_data.uint; break;
1330 case e_slong: m_data.ulonglong >>= rhs.m_data.slong; break;
1331 case e_ulong: m_data.ulonglong >>= rhs.m_data.ulong; break;
1332 case e_slonglong: m_data.ulonglong >>= rhs.m_data.slonglong; break;
1333 case e_ulonglong: m_data.ulonglong >>= rhs.m_data.ulonglong; break;
1334 }
1335 break;
1336 }
1337 return *this;
1338}
1339
1340
1341Scalar&
1342Scalar::operator&= (const Scalar& rhs)
1343{
1344 switch (m_type)
1345 {
1346 default:
1347 case e_void:
1348 case e_float:
1349 case e_double:
1350 case e_long_double:
1351 m_type = e_void;
1352 break;
1353
1354 case e_sint:
1355 switch (rhs.m_type)
1356 {
1357 default:
1358 case e_void:
1359 case e_float:
1360 case e_double:
1361 case e_long_double:
1362 m_type = e_void;
1363 break;
1364 case e_sint: m_data.sint &= rhs.m_data.sint; break;
1365 case e_uint: m_data.sint &= rhs.m_data.uint; break;
1366 case e_slong: m_data.sint &= rhs.m_data.slong; break;
1367 case e_ulong: m_data.sint &= rhs.m_data.ulong; break;
1368 case e_slonglong: m_data.sint &= rhs.m_data.slonglong; break;
1369 case e_ulonglong: m_data.sint &= rhs.m_data.ulonglong; break;
1370 }
1371 break;
1372
1373 case e_uint:
1374 switch (rhs.m_type)
1375 {
1376 default:
1377 case e_void:
1378 case e_float:
1379 case e_double:
1380 case e_long_double:
1381 m_type = e_void;
1382 break;
1383 case e_sint: m_data.uint &= rhs.m_data.sint; break;
1384 case e_uint: m_data.uint &= rhs.m_data.uint; break;
1385 case e_slong: m_data.uint &= rhs.m_data.slong; break;
1386 case e_ulong: m_data.uint &= rhs.m_data.ulong; break;
1387 case e_slonglong: m_data.uint &= rhs.m_data.slonglong; break;
1388 case e_ulonglong: m_data.uint &= rhs.m_data.ulonglong; break;
1389 }
1390 break;
1391
1392 case e_slong:
1393 switch (rhs.m_type)
1394 {
1395 default:
1396 case e_void:
1397 case e_float:
1398 case e_double:
1399 case e_long_double:
1400 m_type = e_void;
1401 break;
1402 case e_sint: m_data.slong &= rhs.m_data.sint; break;
1403 case e_uint: m_data.slong &= rhs.m_data.uint; break;
1404 case e_slong: m_data.slong &= rhs.m_data.slong; break;
1405 case e_ulong: m_data.slong &= rhs.m_data.ulong; break;
1406 case e_slonglong: m_data.slong &= rhs.m_data.slonglong; break;
1407 case e_ulonglong: m_data.slong &= rhs.m_data.ulonglong; break;
1408 }
1409 break;
1410
1411 case e_ulong:
1412 switch (rhs.m_type)
1413 {
1414 default:
1415 case e_void:
1416 case e_float:
1417 case e_double:
1418 case e_long_double:
1419 m_type = e_void;
1420 break;
1421 case e_sint: m_data.ulong &= rhs.m_data.sint; break;
1422 case e_uint: m_data.ulong &= rhs.m_data.uint; break;
1423 case e_slong: m_data.ulong &= rhs.m_data.slong; break;
1424 case e_ulong: m_data.ulong &= rhs.m_data.ulong; break;
1425 case e_slonglong: m_data.ulong &= rhs.m_data.slonglong; break;
1426 case e_ulonglong: m_data.ulong &= rhs.m_data.ulonglong; break;
1427 }
1428 break;
1429 case e_slonglong:
1430 switch (rhs.m_type)
1431 {
1432 default:
1433 case e_void:
1434 case e_float:
1435 case e_double:
1436 case e_long_double:
1437 m_type = e_void;
1438 break;
1439 case e_sint: m_data.slonglong &= rhs.m_data.sint; break;
1440 case e_uint: m_data.slonglong &= rhs.m_data.uint; break;
1441 case e_slong: m_data.slonglong &= rhs.m_data.slong; break;
1442 case e_ulong: m_data.slonglong &= rhs.m_data.ulong; break;
1443 case e_slonglong: m_data.slonglong &= rhs.m_data.slonglong; break;
1444 case e_ulonglong: m_data.slonglong &= rhs.m_data.ulonglong; break;
1445 }
1446 break;
1447
1448 case e_ulonglong:
1449 switch (rhs.m_type)
1450 {
1451 default:
1452 case e_void:
1453 case e_float:
1454 case e_double:
1455 case e_long_double:
1456 m_type = e_void;
1457 break;
1458 case e_sint: m_data.ulonglong &= rhs.m_data.sint; break;
1459 case e_uint: m_data.ulonglong &= rhs.m_data.uint; break;
1460 case e_slong: m_data.ulonglong &= rhs.m_data.slong; break;
1461 case e_ulong: m_data.ulonglong &= rhs.m_data.ulong; break;
1462 case e_slonglong: m_data.ulonglong &= rhs.m_data.slonglong; break;
1463 case e_ulonglong: m_data.ulonglong &= rhs.m_data.ulonglong; break;
1464 }
1465 break;
1466 }
1467 return *this;
1468}
1469
1470
1471
1472bool
1473Scalar::AbsoluteValue()
1474{
1475 switch (m_type)
1476 {
1477 default:
1478 case e_void:
1479 break;
1480
1481 case e_sint:
1482 if (m_data.sint < 0)
1483 m_data.sint = -m_data.sint;
1484 return true;
1485
1486 case e_slong:
1487 if (m_data.slong < 0)
1488 m_data.slong = -m_data.slong;
1489 return true;
1490
1491 case e_slonglong:
1492 if (m_data.slonglong < 0)
1493 m_data.slonglong = -m_data.slonglong;
1494 return true;
1495
1496 case e_uint:
1497 case e_ulong:
1498 case e_ulonglong: return true;
1499 case e_float: m_data.flt = fabsf(m_data.flt); return true;
1500 case e_double: m_data.dbl = fabs(m_data.dbl); return true;
1501 case e_long_double: m_data.ldbl = fabsl(m_data.ldbl); return true;
1502 }
1503 return false;
1504}
1505
1506
1507bool
1508Scalar::UnaryNegate()
1509{
1510 switch (m_type)
1511 {
1512 default:
1513 case e_void: break;
1514 case e_sint: m_data.sint = -m_data.sint; return true;
1515 case e_uint: m_data.uint = -m_data.uint; return true;
1516 case e_slong: m_data.slong = -m_data.slong; return true;
1517 case e_ulong: m_data.ulong = -m_data.ulong; return true;
1518 case e_slonglong: m_data.slonglong = -m_data.slonglong; return true;
1519 case e_ulonglong: m_data.ulonglong = -m_data.ulonglong; return true;
1520 case e_float: m_data.flt = -m_data.flt; return true;
1521 case e_double: m_data.dbl = -m_data.dbl; return true;
1522 case e_long_double: m_data.ldbl = -m_data.ldbl; return true;
1523 }
1524 return false;
1525}
1526
1527bool
1528Scalar::OnesComplement()
1529{
1530 switch (m_type)
1531 {
1532 case e_sint: m_data.sint = ~m_data.sint; return true;
1533 case e_uint: m_data.uint = ~m_data.uint; return true;
1534 case e_slong: m_data.slong = ~m_data.slong; return true;
1535 case e_ulong: m_data.ulong = ~m_data.ulong; return true;
1536 case e_slonglong: m_data.slonglong = ~m_data.slonglong; return true;
1537 case e_ulonglong: m_data.ulonglong = ~m_data.ulonglong; return true;
1538
1539 default:
1540 case e_void:
1541 case e_float:
1542 case e_double:
1543 case e_long_double:
1544 break;
1545 }
1546 return false;
1547}
1548
1549
1550const Scalar
1551lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
1552{
1553 Scalar result;
1554 Scalar temp_value;
1555 const Scalar* a;
1556 const Scalar* b;
1557 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1558 {
1559 switch (result.m_type)
1560 {
1561 default:
1562 case Scalar::e_void: break;
1563 case Scalar::e_sint: result.m_data.sint = a->m_data.sint + b->m_data.sint; break;
1564 case Scalar::e_uint: result.m_data.uint = a->m_data.uint + b->m_data.uint; break;
1565 case Scalar::e_slong: result.m_data.slong = a->m_data.slong + b->m_data.slong; break;
1566 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong + b->m_data.ulong; break;
1567 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong + b->m_data.slonglong; break;
1568 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong + b->m_data.ulonglong; break;
1569 case Scalar::e_float: result.m_data.flt = a->m_data.flt + b->m_data.flt; break;
1570 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl + b->m_data.dbl; break;
1571 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl + b->m_data.ldbl; break;
1572 }
1573 }
1574 return result;
1575}
1576
1577
1578const Scalar
1579lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
1580{
1581 Scalar result;
1582 Scalar temp_value;
1583 const Scalar* a;
1584 const Scalar* b;
1585 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1586 {
1587 switch (result.m_type)
1588 {
1589 default:
1590 case Scalar::e_void: break;
1591 case Scalar::e_sint: result.m_data.sint = a->m_data.sint - b->m_data.sint; break;
1592 case Scalar::e_uint: result.m_data.uint = a->m_data.uint - b->m_data.uint; break;
1593 case Scalar::e_slong: result.m_data.slong = a->m_data.slong - b->m_data.slong; break;
1594 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong - b->m_data.ulong; break;
1595 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong - b->m_data.slonglong; break;
1596 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong - b->m_data.ulonglong; break;
1597 case Scalar::e_float: result.m_data.flt = a->m_data.flt - b->m_data.flt; break;
1598 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl - b->m_data.dbl; break;
1599 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl - b->m_data.ldbl; break;
1600 }
1601 }
1602 return result;
1603}
1604
1605const Scalar
1606lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
1607{
1608 Scalar result;
1609 Scalar temp_value;
1610 const Scalar* a;
1611 const Scalar* b;
1612 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1613 {
1614 switch (result.m_type)
1615 {
1616 default:
1617 case Scalar::e_void: break;
1618
1619 case Scalar::e_sint: if (b->m_data.sint != 0) { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break;
1620 case Scalar::e_uint: if (b->m_data.uint != 0) { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break;
1621 case Scalar::e_slong: if (b->m_data.slong != 0) { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break;
1622 case Scalar::e_ulong: if (b->m_data.ulong != 0) { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break;
1623 case Scalar::e_slonglong: if (b->m_data.slonglong != 0) { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break;
1624 case Scalar::e_ulonglong: if (b->m_data.ulonglong != 0) { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break;
1625 case Scalar::e_float: if (b->m_data.flt != 0.0f) { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break;
1626 case Scalar::e_double: if (b->m_data.dbl != 0.0) { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break;
1627 case Scalar::e_long_double: if (b->m_data.ldbl != 0.0) { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break;
1628 }
1629 }
1630 // For division only, the only way it should make it here is if a promotion failed,
1631 // or if we are trying to do a divide by zero.
1632 result.m_type = Scalar::e_void;
1633 return result;
1634}
1635
1636const Scalar
1637lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
1638{
1639 Scalar result;
1640 Scalar temp_value;
1641 const Scalar* a;
1642 const Scalar* b;
1643 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1644 {
1645 switch (result.m_type)
1646 {
1647 default:
1648 case Scalar::e_void: break;
1649 case Scalar::e_sint: result.m_data.sint = a->m_data.sint * b->m_data.sint; break;
1650 case Scalar::e_uint: result.m_data.uint = a->m_data.uint * b->m_data.uint; break;
1651 case Scalar::e_slong: result.m_data.slong = a->m_data.slong * b->m_data.slong; break;
1652 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong * b->m_data.ulong; break;
1653 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong * b->m_data.slonglong; break;
1654 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong * b->m_data.ulonglong; break;
1655 case Scalar::e_float: result.m_data.flt = a->m_data.flt * b->m_data.flt; break;
1656 case Scalar::e_double: result.m_data.dbl = a->m_data.dbl * b->m_data.dbl; break;
1657 case Scalar::e_long_double: result.m_data.ldbl = a->m_data.ldbl * b->m_data.ldbl; break;
1658 }
1659 }
1660 return result;
1661}
1662
1663const Scalar
1664lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
1665{
1666 Scalar result;
1667 Scalar temp_value;
1668 const Scalar* a;
1669 const Scalar* b;
1670 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1671 {
1672 switch (result.m_type)
1673 {
1674 case Scalar::e_sint: result.m_data.sint = a->m_data.sint & b->m_data.sint; break;
1675 case Scalar::e_uint: result.m_data.uint = a->m_data.uint & b->m_data.uint; break;
1676 case Scalar::e_slong: result.m_data.slong = a->m_data.slong & b->m_data.slong; break;
1677 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong & b->m_data.ulong; break;
1678 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong & b->m_data.slonglong; break;
1679 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong & b->m_data.ulonglong; break;
1680
1681 default:
1682 case Scalar::e_void:
1683 case Scalar::e_float:
1684 case Scalar::e_double:
1685 case Scalar::e_long_double:
1686 // No bitwise AND on floats, doubles of long doubles
1687 result.m_type = Scalar::e_void;
1688 break;
1689 }
1690 }
1691 return result;
1692}
1693
1694const Scalar
1695lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
1696{
1697 Scalar result;
1698 Scalar temp_value;
1699 const Scalar* a;
1700 const Scalar* b;
1701 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1702 {
1703 switch (result.m_type)
1704 {
1705 case Scalar::e_sint: result.m_data.sint = a->m_data.sint | b->m_data.sint; break;
1706 case Scalar::e_uint: result.m_data.uint = a->m_data.uint | b->m_data.uint; break;
1707 case Scalar::e_slong: result.m_data.slong = a->m_data.slong | b->m_data.slong; break;
1708 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong | b->m_data.ulong; break;
1709 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong | b->m_data.slonglong; break;
1710 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong | b->m_data.ulonglong; break;
1711
1712 default:
1713 case Scalar::e_void:
1714 case Scalar::e_float:
1715 case Scalar::e_double:
1716 case Scalar::e_long_double:
1717 // No bitwise AND on floats, doubles of long doubles
1718 result.m_type = Scalar::e_void;
1719 break;
1720 }
1721 }
1722 return result;
1723}
1724
1725const Scalar
1726lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
1727{
1728 Scalar result;
1729 Scalar temp_value;
1730 const Scalar* a;
1731 const Scalar* b;
1732 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1733 {
1734 switch (result.m_type)
1735 {
1736 case Scalar::e_sint: result.m_data.sint = a->m_data.sint % b->m_data.sint; break;
1737 case Scalar::e_uint: result.m_data.uint = a->m_data.uint % b->m_data.uint; break;
1738 case Scalar::e_slong: result.m_data.slong = a->m_data.slong % b->m_data.slong; break;
1739 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong % b->m_data.ulong; break;
1740 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong % b->m_data.slonglong; break;
1741 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong % b->m_data.ulonglong; break;
1742
1743 default:
1744 case Scalar::e_void:
1745 case Scalar::e_float:
1746 case Scalar::e_double:
1747 case Scalar::e_long_double:
1748 // No bitwise AND on floats, doubles of long doubles
1749 result.m_type = Scalar::e_void;
1750 break;
1751 }
1752 }
1753 return result;
1754}
1755
1756const Scalar
1757lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
1758{
1759 Scalar result;
1760 Scalar temp_value;
1761 const Scalar* a;
1762 const Scalar* b;
1763 if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1764 {
1765 switch (result.m_type)
1766 {
1767 case Scalar::e_sint: result.m_data.sint = a->m_data.sint ^ b->m_data.sint; break;
1768 case Scalar::e_uint: result.m_data.uint = a->m_data.uint ^ b->m_data.uint; break;
1769 case Scalar::e_slong: result.m_data.slong = a->m_data.slong ^ b->m_data.slong; break;
1770 case Scalar::e_ulong: result.m_data.ulong = a->m_data.ulong ^ b->m_data.ulong; break;
1771 case Scalar::e_slonglong: result.m_data.slonglong = a->m_data.slonglong ^ b->m_data.slonglong; break;
1772 case Scalar::e_ulonglong: result.m_data.ulonglong = a->m_data.ulonglong ^ b->m_data.ulonglong; break;
1773
1774 default:
1775 case Scalar::e_void:
1776 case Scalar::e_float:
1777 case Scalar::e_double:
1778 case Scalar::e_long_double:
1779 // No bitwise AND on floats, doubles of long doubles
1780 result.m_type = Scalar::e_void;
1781 break;
1782 }
1783 }
1784 return result;
1785}
1786
1787// Return the raw unsigned integer without any casting or conversion
1788unsigned int
1789Scalar::RawUInt () const
1790{
1791 return m_data.uint;
1792}
1793
1794// Return the raw unsigned long without any casting or conversion
1795unsigned long
1796Scalar::RawULong () const
1797{
1798 return m_data.ulong;
1799}
1800
1801// Return the raw unsigned long long without any casting or conversion
1802unsigned long long
1803Scalar::RawULongLong () const
1804{
1805 return m_data.ulonglong;
1806}
1807
1808
1809Error
1810Scalar::SetValueFromCString (const char *value_str, Encoding encoding, uint32_t byte_size)
1811{
1812 Error error;
1813 if (value_str == NULL && value_str[0] == '\0')
1814 {
1815 error.SetErrorString ("Invalid c-string value string.");
1816 return error;
1817 }
1818 bool success = false;
1819 switch (encoding)
1820 {
1821 default:
1822 case eEncodingInvalid:
1823 error.SetErrorString ("Invalid encoding.");
1824 break;
1825
1826 case eEncodingUint:
1827 if (byte_size <= sizeof (unsigned long long))
1828 {
1829 uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
1830 if (!success)
1831 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value.\n", value_str);
1832 else if (!UIntValueIsValidForSize (uval64, byte_size))
1833 error.SetErrorStringWithFormat ("Value 0x%llx is too large to fit in a %u byte unsigned integer value.\n", uval64, byte_size);
1834 else
1835 {
1836 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
1837 switch (m_type)
1838 {
1839 case e_uint: m_data.uint = uval64; break;
1840 case e_ulong: m_data.ulong = uval64; break;
1841 case e_ulonglong: m_data.ulonglong = uval64; break;
1842 default:
1843 error.SetErrorStringWithFormat ("Unsupported unsigned integer byte size: %u.\n", byte_size);
1844 break;
1845 }
1846 }
1847 }
1848 else
1849 {
1850 error.SetErrorStringWithFormat ("Unsupported unsigned integer byte size: %u.\n", byte_size);
1851 return error;
1852 }
1853 break;
1854
1855 case eEncodingSint:
1856 if (byte_size <= sizeof (long long))
1857 {
1858 uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
1859 if (!success)
1860 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value.\n", value_str);
1861 else if (!SIntValueIsValidForSize (sval64, byte_size))
1862 error.SetErrorStringWithFormat ("Value 0x%llx is too large to fit in a %u byte signed integer value.\n", sval64, byte_size);
1863 else
1864 {
1865 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
1866 switch (m_type)
1867 {
1868 case e_sint: m_data.sint = sval64; break;
1869 case e_slong: m_data.slong = sval64; break;
1870 case e_slonglong: m_data.slonglong = sval64; break;
1871 default:
1872 error.SetErrorStringWithFormat ("Unsupported signed integer byte size: %u.\n", byte_size);
1873 break;
1874 }
1875 }
1876 }
1877 else
1878 {
1879 error.SetErrorStringWithFormat ("Unsupported signed integer byte size: %u.\n", byte_size);
1880 return error;
1881 }
1882 break;
1883
1884 case eEncodingIEEE754:
1885 if (byte_size == sizeof (float))
1886 {
1887 if (::sscanf (value_str, "%f", &m_data.flt) == 1)
1888 m_type = e_float;
1889 else
1890 error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str);
1891 }
1892 else if (byte_size == sizeof (double))
1893 {
1894 if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
1895 m_type = e_double;
1896 else
1897 error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str);
1898 }
1899 else if (byte_size == sizeof (long double))
1900 {
1901 if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
1902 m_type = e_long_double;
1903 else
1904 error.SetErrorStringWithFormat ("'%s' is not a valid float string value.\n", value_str);
1905 }
1906 else
1907 {
1908 error.SetErrorStringWithFormat ("Unsupported float byte size: %u.\n", byte_size);
1909 return error;
1910 }
1911 break;
1912
1913 case eEncodingVector:
1914 error.SetErrorString ("Vector encoding unsupported.");
1915 break;
1916 }
1917 if (error.Fail())
1918 m_type = e_void;
1919
1920 return error;
1921}
1922
1923bool
1924lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
1925{
1926 // If either entry is void then we can just compare the types
1927 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
1928 return lhs.m_type == rhs.m_type;
1929
1930 Scalar temp_value;
1931 const Scalar* a;
1932 const Scalar* b;
1933 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
1934 {
1935 default:
1936 case Scalar::e_void: break;
1937 case Scalar::e_sint: return a->m_data.sint == b->m_data.sint;
1938 case Scalar::e_uint: return a->m_data.uint == b->m_data.uint;
1939 case Scalar::e_slong: return a->m_data.slong == b->m_data.slong;
1940 case Scalar::e_ulong: return a->m_data.ulong == b->m_data.ulong;
1941 case Scalar::e_slonglong: return a->m_data.slonglong == b->m_data.slonglong;
1942 case Scalar::e_ulonglong: return a->m_data.ulonglong == b->m_data.ulonglong;
1943 case Scalar::e_float: return a->m_data.flt == b->m_data.flt;
1944 case Scalar::e_double: return a->m_data.dbl == b->m_data.dbl;
1945 case Scalar::e_long_double: return a->m_data.ldbl == b->m_data.ldbl;
1946 }
1947 return false;
1948}
1949
1950bool
1951lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
1952{
1953 // If either entry is void then we can just compare the types
1954 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
1955 return lhs.m_type != rhs.m_type;
1956
1957 Scalar temp_value; // A temp value that might get a copy of either promoted value
1958 const Scalar* a;
1959 const Scalar* b;
1960 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
1961 {
1962 default:
1963 case Scalar::e_void: break;
1964 case Scalar::e_sint: return a->m_data.sint != b->m_data.sint;
1965 case Scalar::e_uint: return a->m_data.uint != b->m_data.uint;
1966 case Scalar::e_slong: return a->m_data.slong != b->m_data.slong;
1967 case Scalar::e_ulong: return a->m_data.ulong != b->m_data.ulong;
1968 case Scalar::e_slonglong: return a->m_data.slonglong != b->m_data.slonglong;
1969 case Scalar::e_ulonglong: return a->m_data.ulonglong != b->m_data.ulonglong;
1970 case Scalar::e_float: return a->m_data.flt != b->m_data.flt;
1971 case Scalar::e_double: return a->m_data.dbl != b->m_data.dbl;
1972 case Scalar::e_long_double: return a->m_data.ldbl != b->m_data.ldbl;
1973 }
1974 return true;
1975}
1976
1977bool
1978lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
1979{
1980 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
1981 return false;
1982
1983 Scalar temp_value;
1984 const Scalar* a;
1985 const Scalar* b;
1986 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
1987 {
1988 default:
1989 case Scalar::e_void: break;
1990 case Scalar::e_sint: return a->m_data.sint < b->m_data.sint;
1991 case Scalar::e_uint: return a->m_data.uint < b->m_data.uint;
1992 case Scalar::e_slong: return a->m_data.slong < b->m_data.slong;
1993 case Scalar::e_ulong: return a->m_data.ulong < b->m_data.ulong;
1994 case Scalar::e_slonglong: return a->m_data.slonglong < b->m_data.slonglong;
1995 case Scalar::e_ulonglong: return a->m_data.ulonglong < b->m_data.ulonglong;
1996 case Scalar::e_float: return a->m_data.flt < b->m_data.flt;
1997 case Scalar::e_double: return a->m_data.dbl < b->m_data.dbl;
1998 case Scalar::e_long_double: return a->m_data.ldbl < b->m_data.ldbl;
1999 }
2000 return false;
2001}
2002
2003bool
2004lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
2005{
2006 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2007 return false;
2008
2009 Scalar temp_value;
2010 const Scalar* a;
2011 const Scalar* b;
2012 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2013 {
2014 default:
2015 case Scalar::e_void: break;
2016 case Scalar::e_sint: return a->m_data.sint <= b->m_data.sint;
2017 case Scalar::e_uint: return a->m_data.uint <= b->m_data.uint;
2018 case Scalar::e_slong: return a->m_data.slong <= b->m_data.slong;
2019 case Scalar::e_ulong: return a->m_data.ulong <= b->m_data.ulong;
2020 case Scalar::e_slonglong: return a->m_data.slonglong <= b->m_data.slonglong;
2021 case Scalar::e_ulonglong: return a->m_data.ulonglong <= b->m_data.ulonglong;
2022 case Scalar::e_float: return a->m_data.flt <= b->m_data.flt;
2023 case Scalar::e_double: return a->m_data.dbl <= b->m_data.dbl;
2024 case Scalar::e_long_double: return a->m_data.ldbl <= b->m_data.ldbl;
2025 }
2026 return false;
2027}
2028
2029
2030bool
2031lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
2032{
2033 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2034 return false;
2035
2036 Scalar temp_value;
2037 const Scalar* a;
2038 const Scalar* b;
2039 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2040 {
2041 default:
2042 case Scalar::e_void: break;
2043 case Scalar::e_sint: return a->m_data.sint > b->m_data.sint;
2044 case Scalar::e_uint: return a->m_data.uint > b->m_data.uint;
2045 case Scalar::e_slong: return a->m_data.slong > b->m_data.slong;
2046 case Scalar::e_ulong: return a->m_data.ulong > b->m_data.ulong;
2047 case Scalar::e_slonglong: return a->m_data.slonglong > b->m_data.slonglong;
2048 case Scalar::e_ulonglong: return a->m_data.ulonglong > b->m_data.ulonglong;
2049 case Scalar::e_float: return a->m_data.flt > b->m_data.flt;
2050 case Scalar::e_double: return a->m_data.dbl > b->m_data.dbl;
2051 case Scalar::e_long_double: return a->m_data.ldbl > b->m_data.ldbl;
2052 }
2053 return false;
2054}
2055
2056bool
2057lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
2058{
2059 if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2060 return false;
2061
2062 Scalar temp_value;
2063 const Scalar* a;
2064 const Scalar* b;
2065 switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2066 {
2067 default:
2068 case Scalar::e_void: break;
2069 case Scalar::e_sint: return a->m_data.sint >= b->m_data.sint;
2070 case Scalar::e_uint: return a->m_data.uint >= b->m_data.uint;
2071 case Scalar::e_slong: return a->m_data.slong >= b->m_data.slong;
2072 case Scalar::e_ulong: return a->m_data.ulong >= b->m_data.ulong;
2073 case Scalar::e_slonglong: return a->m_data.slonglong >= b->m_data.slonglong;
2074 case Scalar::e_ulonglong: return a->m_data.ulonglong >= b->m_data.ulonglong;
2075 case Scalar::e_float: return a->m_data.flt >= b->m_data.flt;
2076 case Scalar::e_double: return a->m_data.dbl >= b->m_data.dbl;
2077 case Scalar::e_long_double: return a->m_data.ldbl >= b->m_data.ldbl;
2078 }
2079 return false;
2080}
2081
2082
2083
2084