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