[haiku-commits] haiku: hrev48119 - in src/apps/debugger: types source_language/expression_evaluators source_language user_interface/gui
- From: anevilyak@xxxxxxxxx
- To: haiku-commits@xxxxxxxxxxxxx
- Date: Mon, 27 Oct 2014 16:54:45 +0100 (CET)
hrev48119 adds 3 changesets to branch 'master'
old head: 5d5ec05b1df089eff03f04a7122ac7cf355c4f3e
new head: 1b629877b1ee4c31f8d4eaed00d253abccd087f5
overview: http://cgit.haiku-os.org/haiku/log/?qt=range&q=1b62987+%5E5d5ec05
----------------------------------------------------------------------------
1c6c5f3: Debugger: Add Number class for expression usage.
- This class abstracts out the underlying type of a value, and handles
all the basic mathematical logical operators accordingly. Replaces
the MAPM type previously used for these respective operations.
fc8713b: Debugger: Rework expression evaluator.
CLanguageExpressionEvaluator:
- Revise to make use of Number class rather than MAPM. In the process,
implement support for bitwise operators.
SourceLanguage/CLanguageFamily/CLanguageExpressionEvaluator:
- Adjust interface for expression evaluation to allow specifying the
type to evaluate the expression as. Adjust implementing classes
accordingly.
ExpressionEvaluationWindow:
- Adjust to new expression interface. For now defaults to 64-bit integer
type, UI for type selection to be added.
1b62987: Debugger: Cleanups.
- Remove dependency on MAPM/ExpressionParser. Consequently also adjust
CliDumpMemoryCommand, InspectorWindow and WatchPromptWindow to use
CLanguageExpressionEvaluator for address input evaluation.
[ Rene Gollent <rene@xxxxxxxxxxx> ]
----------------------------------------------------------------------------
13 files changed, 1227 insertions(+), 187 deletions(-)
src/apps/debugger/Jamfile | 4 +-
.../debugger/source_language/CLanguageFamily.cpp | 34 +-
.../debugger/source_language/CLanguageFamily.h | 2 +-
.../debugger/source_language/SourceLanguage.cpp | 2 +-
.../debugger/source_language/SourceLanguage.h | 2 +-
.../CLanguageExpressionEvaluator.cpp | 237 ++--
.../CLanguageExpressionEvaluator.h | 26 +-
src/apps/debugger/types/Number.cpp | 1008 ++++++++++++++++++
src/apps/debugger/types/Number.h | 56 +
.../cli/commands/CliDumpMemoryCommand.cpp | 12 +-
.../gui/inspector_window/InspectorWindow.cpp | 12 +-
.../team_window/ExpressionEvaluationWindow.cpp | 2 +-
.../gui/team_window/WatchPromptWindow.cpp | 17 +-
############################################################################
Commit: 1c6c5f3b57c2634b7666aff000b3aec13208c37e
URL: http://cgit.haiku-os.org/haiku/commit/?id=1c6c5f3
Author: Rene Gollent <rene@xxxxxxxxxxx>
Date: Mon Oct 27 15:31:39 2014 UTC
Debugger: Add Number class for expression usage.
- This class abstracts out the underlying type of a value, and handles
all the basic mathematical logical operators accordingly. Replaces
the MAPM type previously used for these respective operations.
----------------------------------------------------------------------------
diff --git a/src/apps/debugger/Jamfile b/src/apps/debugger/Jamfile
index ca763a8..3c73006 100644
--- a/src/apps/debugger/Jamfile
+++ b/src/apps/debugger/Jamfile
@@ -219,6 +219,7 @@ Application Debugger :
# types
ArrayIndexPath.cpp
+ Number.cpp
TargetAddressRangeList.cpp
ValueLocation.cpp
diff --git a/src/apps/debugger/types/Number.cpp
b/src/apps/debugger/types/Number.cpp
new file mode 100644
index 0000000..b8e007a
--- /dev/null
+++ b/src/apps/debugger/types/Number.cpp
@@ -0,0 +1,1008 @@
+/*
+ * Copyright 2014, Rene Gollent, rene@xxxxxxxxxxx.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include "Number.h"
+
+#include <stdlib.h>
+
+#include <String.h>
+
+
+Number::Number()
+ :
+ fValue()
+{
+}
+
+
+Number::~Number()
+{
+}
+
+
+Number::Number(type_code type, const BString& value)
+{
+ SetTo(type, value);
+}
+
+
+Number::Number(const BVariant& value)
+ :
+ fValue(value)
+{
+}
+
+
+Number::Number(const Number& other)
+ :
+ fValue(other.fValue)
+{
+}
+
+
+void
+Number::SetTo(type_code type, const BString& value, int32 base)
+{
+ switch (type) {
+ case B_INT8_TYPE:
+ {
+ int8 tempValue = (int8)strtol(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ uint8 tempValue = (uint8)strtoul(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ int16 tempValue = (int16)strtol(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ uint16 tempValue = (uint16)strtoul(value.String(),
NULL, base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ int32 tempValue = (int32)strtol(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ uint32 tempValue = (int32)strtoul(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ int64 tempValue = (int64)strtoll(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ uint64 tempValue = (uint64)strtol(value.String(), NULL,
base);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ float tempValue = strtof(value.String(), NULL);
+ fValue.SetTo(tempValue);
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ double tempValue = strtod(value.String(), NULL);
+ fValue.SetTo(tempValue);
+ break;
+ }
+ }
+}
+
+
+void
+Number::SetTo(const BVariant& value)
+{
+ fValue = value;
+}
+
+
+Number&
+Number::operator=(const Number& rhs)
+{
+ fValue = rhs.fValue;
+ return *this;
+}
+
+
+Number&
+Number::operator+=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() +
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() +
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() +
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() +
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() + rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() + rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() + rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() + rhs.fValue.ToUInt64());
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ fValue.SetTo(fValue.ToFloat() + rhs.fValue.ToFloat());
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ fValue.SetTo(fValue.ToDouble() + rhs.fValue.ToDouble());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator-=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() -
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() -
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() -
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() -
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() - rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() - rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() - rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() - rhs.fValue.ToUInt64());
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ fValue.SetTo(fValue.ToFloat() - rhs.fValue.ToFloat());
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ fValue.SetTo(fValue.ToDouble() - rhs.fValue.ToDouble());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator/=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() /
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() /
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() /
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() /
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() / rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() / rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() / rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() / rhs.fValue.ToUInt64());
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ fValue.SetTo(fValue.ToFloat() / rhs.fValue.ToFloat());
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ fValue.SetTo(fValue.ToDouble() / rhs.fValue.ToDouble());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator%=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() %
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() %
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() %
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() %
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() % rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() % rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() % rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() % rhs.fValue.ToUInt64());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator*=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() *
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() *
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() *
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() *
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() * rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() * rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() * rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() * rhs.fValue.ToUInt64());
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ fValue.SetTo(fValue.ToFloat() * rhs.fValue.ToFloat());
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ fValue.SetTo(fValue.ToDouble() * rhs.fValue.ToDouble());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator&=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() &
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() &
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() &
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() &
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() & rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() & rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() & rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() & rhs.fValue.ToUInt64());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator|=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() |
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() |
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() |
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() |
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() | rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() | rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() | rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() | rhs.fValue.ToUInt64());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number&
+Number::operator^=(const Number& rhs)
+{
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ fValue.SetTo((int8)(fValue.ToInt8() ^
rhs.fValue.ToInt8()));
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ fValue.SetTo((uint8)(fValue.ToUInt8() ^
rhs.fValue.ToUInt8()));
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ fValue.SetTo((int16)(fValue.ToInt16() ^
rhs.fValue.ToInt16()));
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ fValue.SetTo((uint16)(fValue.ToUInt16() ^
rhs.fValue.ToUInt16()));
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt32() ^ rhs.fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt32() ^ rhs.fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToInt64() ^ rhs.fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ fValue.SetTo(fValue.ToUInt64() ^ rhs.fValue.ToUInt64());
+ break;
+ }
+ }
+
+ return *this;
+}
+
+
+Number
+Number::operator-() const
+{
+ Number value(*this);
+
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ value.fValue.SetTo((int8)-fValue.ToInt8());
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ value.fValue.SetTo((uint8)-fValue.ToUInt8());
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ value.fValue.SetTo((int16)-fValue.ToInt16());
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ value.fValue.SetTo((uint16)-fValue.ToUInt16());
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ value.fValue.SetTo(-fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ value.fValue.SetTo(-fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ value.fValue.SetTo(-fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ value.fValue.SetTo(-fValue.ToUInt64());
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ value.fValue.SetTo(-fValue.ToFloat());
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ value.fValue.SetTo(-fValue.ToDouble());
+ break;
+ }
+ }
+
+ return value;
+}
+
+
+Number
+Number::operator~() const
+{
+ Number value(*this);
+
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ value.fValue.SetTo((int8)~fValue.ToInt8());
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ value.fValue.SetTo((uint8)~fValue.ToUInt8());
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ value.fValue.SetTo((int16)~fValue.ToInt16());
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ value.fValue.SetTo((uint16)~fValue.ToUInt16());
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ value.fValue.SetTo(~fValue.ToInt32());
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ value.fValue.SetTo(~fValue.ToUInt32());
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ value.fValue.SetTo(~fValue.ToInt64());
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ value.fValue.SetTo(~fValue.ToUInt64());
+ break;
+ }
+ }
+
+ return value;
+}
+
+
+int
+Number::operator<(const Number& rhs) const
+{
+ int result = 0;
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ result = fValue.ToInt8() < rhs.fValue.ToInt8();
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ result = fValue.ToUInt8() < rhs.fValue.ToUInt8();
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ result = fValue.ToInt16() < rhs.fValue.ToInt16();
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ result = fValue.ToUInt16() < rhs.fValue.ToUInt16();
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ result = fValue.ToInt32() < rhs.fValue.ToInt32();
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ result = fValue.ToUInt32() < rhs.fValue.ToUInt32();
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ result = fValue.ToInt64() < rhs.fValue.ToInt64();
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ result = fValue.ToUInt64() < rhs.fValue.ToUInt64();
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ result = fValue.ToFloat() < rhs.fValue.ToFloat();
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ result = fValue.ToDouble() < rhs.fValue.ToDouble();
+ break;
+ }
+ }
+
+ return result;
+}
+
+
+int
+Number::operator<=(const Number& rhs) const
+{
+ return (*this < rhs) || (*this == rhs);
+}
+
+
+int
+Number::operator>(const Number& rhs) const
+{
+ int result = 0;
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ result = fValue.ToInt8() > rhs.fValue.ToInt8();
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ result = fValue.ToUInt8() > rhs.fValue.ToUInt8();
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ result = fValue.ToInt16() > rhs.fValue.ToInt16();
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ result = fValue.ToUInt16() > rhs.fValue.ToUInt16();
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ result = fValue.ToInt32() > rhs.fValue.ToInt32();
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ result = fValue.ToUInt32() > rhs.fValue.ToUInt32();
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ result = fValue.ToInt64() > rhs.fValue.ToInt64();
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ result = fValue.ToUInt64() > rhs.fValue.ToUInt64();
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ result = fValue.ToFloat() > rhs.fValue.ToFloat();
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ result = fValue.ToDouble() > rhs.fValue.ToDouble();
+ break;
+ }
+ }
+
+ return result;
+}
+
+
+int
+Number::operator>=(const Number& rhs) const
+{
+ return (*this > rhs) || (*this == rhs);
+}
+
+
+int
+Number::operator==(const Number& rhs) const
+{
+ int result = 0;
+ switch (fValue.Type()) {
+ case B_INT8_TYPE:
+ {
+ result = fValue.ToInt8() == rhs.fValue.ToInt8();
+ break;
+ }
+
+ case B_UINT8_TYPE:
+ {
+ result = fValue.ToUInt8() == rhs.fValue.ToUInt8();
+ break;
+ }
+
+ case B_INT16_TYPE:
+ {
+ result = fValue.ToInt16() == rhs.fValue.ToInt16();
+ break;
+ }
+
+ case B_UINT16_TYPE:
+ {
+ result = fValue.ToUInt16() == rhs.fValue.ToUInt16();
+ break;
+ }
+
+ case B_INT32_TYPE:
+ {
+ result = fValue.ToInt32() == rhs.fValue.ToInt32();
+ break;
+ }
+
+ case B_UINT32_TYPE:
+ {
+ result = fValue.ToUInt32() == rhs.fValue.ToUInt32();
+ break;
+ }
+
+ case B_INT64_TYPE:
+ {
+ result = fValue.ToInt64() == rhs.fValue.ToInt64();
+ break;
+ }
+
+ case B_UINT64_TYPE:
+ {
+ result = fValue.ToUInt64() == rhs.fValue.ToUInt64();
+ break;
+ }
+
+ case B_FLOAT_TYPE:
+ {
+ result = fValue.ToFloat() == rhs.fValue.ToFloat();
+ break;
+ }
+
+ case B_DOUBLE_TYPE:
+ {
+ result = fValue.ToDouble() == rhs.fValue.ToDouble();
+ break;
+ }
+ }
+
+ return result;
+}
+
+
+int
+Number::operator!=(const Number& rhs) const
+{
+ return !(*this == rhs);
+}
+
+
+BVariant
+Number::GetValue() const
+{
+ return fValue;
+}
+
diff --git a/src/apps/debugger/types/Number.h b/src/apps/debugger/types/Number.h
new file mode 100644
index 0000000..fcbd95f
--- /dev/null
+++ b/src/apps/debugger/types/Number.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2014, Rene Gollent, rene@xxxxxxxxxxx.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef NUMBER_H
+#define NUMBER_H
+
+#include <TypeConstants.h>
+
+#include "Variant.h"
+
+
+class BString;
+
+
+class Number {
+public:
+ Number();
+ virtual ~Number();
+
Number(type_code type, const BString& value);
+ Number(const
BVariant& value);
+ Number(const
Number& other);
+
+ void SetTo(type_code type,
const BString& value,
+ int32
base = 10);
+ void SetTo(const BVariant&
value);
+
+ Number& operator=(const Number&
rhs);
+ Number& operator+=(const
Number& rhs);
+ Number& operator-=(const
Number& rhs);
+ Number& operator/=(const
Number& rhs);
+ Number& operator*=(const
Number& rhs);
+ Number& operator%=(const
Number& rhs);
+
+ Number& operator&=(const
Number& rhs);
+ Number& operator|=(const
Number& rhs);
+ Number& operator^=(const
Number& rhs);
+
+ Number operator-() const;
+ Number operator~() const;
+
+ int operator<(const
Number& rhs) const;
+ int
operator<=(const Number& rhs) const;
+ int operator>(const
Number& rhs) const;
+ int
operator>=(const Number& rhs) const;
+ int
operator==(const Number& rhs) const;
+ int
operator!=(const Number& rhs) const;
+
+ BVariant GetValue() const;
+
+private:
+ BVariant fValue;
+};
+
+
+#endif // NUMBER_H
############################################################################
Commit: fc8713b02e4382a0c66f0a063c73a0cc082c5133
URL: http://cgit.haiku-os.org/haiku/commit/?id=fc8713b
Author: Rene Gollent <rene@xxxxxxxxxxx>
Date: Mon Oct 27 15:42:58 2014 UTC
Debugger: Rework expression evaluator.
CLanguageExpressionEvaluator:
- Revise to make use of Number class rather than MAPM. In the process,
implement support for bitwise operators.
SourceLanguage/CLanguageFamily/CLanguageExpressionEvaluator:
- Adjust interface for expression evaluation to allow specifying the
type to evaluate the expression as. Adjust implementing classes
accordingly.
ExpressionEvaluationWindow:
- Adjust to new expression interface. For now defaults to 64-bit integer
type, UI for type selection to be added.
----------------------------------------------------------------------------
diff --git a/src/apps/debugger/source_language/CLanguageFamily.cpp
b/src/apps/debugger/source_language/CLanguageFamily.cpp
index b56e2bc..eb4884c 100644
--- a/src/apps/debugger/source_language/CLanguageFamily.cpp
+++ b/src/apps/debugger/source_language/CLanguageFamily.cpp
@@ -11,7 +11,9 @@
#include <stdlib.h>
#include "CLanguageExpressionEvaluator.h"
+#include "FloatValue.h"
#include "IntegerValue.h"
+#include "Number.h"
#include "StringValue.h"
#include "TeamTypeInformation.h"
#include "Type.h"
@@ -165,16 +167,36 @@ CLanguageFamily::ParseTypeExpression(const BString&
expression,
status_t
-CLanguageFamily::EvaluateExpression(const BString& expression, Value*& _output)
+CLanguageFamily::EvaluateExpression(const BString& expression,
+ type_code type, Value*& _output)
{
_output = NULL;
CLanguageExpressionEvaluator evaluator;
- evaluator.SetSupportHexInput(true);
- int64 resultValue;
+ Number result;
try {
- resultValue = evaluator.EvaluateToInt64(expression);
- BVariant variantValue(resultValue);
- _output = new(std::nothrow) IntegerValue(variantValue);
+ result = evaluator.Evaluate(expression, type);
+ BVariant resultValue = result.GetValue();
+ switch (type) {
+ case B_INT8_TYPE:
+ case B_UINT8_TYPE:
+ case B_INT16_TYPE:
+ case B_UINT16_TYPE:
+ case B_INT32_TYPE:
+ case B_UINT32_TYPE:
+ case B_INT64_TYPE:
+ case B_UINT64_TYPE:
+ _output = new(std::nothrow)
IntegerValue(resultValue);
+ break;
+
+ case B_FLOAT_TYPE:
+ _output = new(std::nothrow)
FloatValue(resultValue.ToFloat());
+ break;
+
+ case B_DOUBLE_TYPE:
+ _output = new(std::nothrow)
FloatValue(resultValue.ToDouble());
+ break;
+ }
+
if (_output == NULL)
return B_NO_MEMORY;
diff --git a/src/apps/debugger/source_language/CLanguageFamily.h
b/src/apps/debugger/source_language/CLanguageFamily.h
index e7e9f28..a5e7430 100644
--- a/src/apps/debugger/source_language/CLanguageFamily.h
+++ b/src/apps/debugger/source_language/CLanguageFamily.h
@@ -22,7 +22,7 @@ public:
Type*&
_resultType) const;
virtual status_t EvaluateExpression(const
BString& expression,
- Value*&
_output);
+
type_code type, Value*& _output);
protected:
virtual bool IsModifierValid(char modifier)
const = 0;
diff --git a/src/apps/debugger/source_language/SourceLanguage.cpp
b/src/apps/debugger/source_language/SourceLanguage.cpp
index 8b11049..da77ea7 100644
--- a/src/apps/debugger/source_language/SourceLanguage.cpp
+++ b/src/apps/debugger/source_language/SourceLanguage.cpp
@@ -30,7 +30,7 @@ SourceLanguage::ParseTypeExpression(const BString& expression,
status_t
SourceLanguage::EvaluateExpression(const BString& expression,
- Value*& _resultValue)
+ type_code type, Value*& _resultValue)
{
return B_NOT_SUPPORTED;
}
diff --git a/src/apps/debugger/source_language/SourceLanguage.h
b/src/apps/debugger/source_language/SourceLanguage.h
index 2f607ad..f609f0f 100644
--- a/src/apps/debugger/source_language/SourceLanguage.h
+++ b/src/apps/debugger/source_language/SourceLanguage.h
@@ -32,7 +32,7 @@ public:
Type*&
_resultType) const;
virtual status_t EvaluateExpression(const
BString& expression,
- Value*&
_output);
+
type_code type, Value*& _output);
};
diff --git
a/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.cpp
b/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.cpp
index 4eacb5e..27a8a93 100644
---
a/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.cpp
+++
b/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.cpp
@@ -11,17 +11,13 @@
#include "CLanguageExpressionEvaluator.h"
+#include "Number.h"
+
#include <ctype.h>
-#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
-#include <m_apm.h>
-
-
-static const int32 kMaxDecimalPlaces = 32;
-
enum {
TOKEN_NONE = 0,
@@ -47,6 +43,7 @@ enum {
TOKEN_BITWISE_AND,
TOKEN_BITWISE_OR,
TOKEN_BITWISE_NOT,
+ TOKEN_BITWISE_XOR,
TOKEN_EQ,
TOKEN_NE,
TOKEN_GT,
@@ -81,7 +78,7 @@ static BString TokenTypeToString(int32 type)
break;
case TOKEN_POWER:
- token = "^";
+ token = "**";
break;
case TOKEN_OPENING_BRACKET:
@@ -116,6 +113,10 @@ static BString TokenTypeToString(int32 type)
token = "~";
break;
+ case TOKEN_BITWISE_XOR:
+ token = "^";
+ break;
+
case TOKEN_EQ:
token = "==";
break;
@@ -153,7 +154,7 @@ struct CLanguageExpressionEvaluator::Token {
Token()
: string(""),
type(TOKEN_NONE),
- value(0),
+ value(0L),
position(0)
{
}
@@ -169,7 +170,7 @@ struct CLanguageExpressionEvaluator::Token {
Token(const char* string, int32 length, int32 position, int32 type)
: string(string, length),
type(type),
- value(0),
+ value(),
position(position)
{
}
@@ -185,7 +186,7 @@ struct CLanguageExpressionEvaluator::Token {
BString string;
int32 type;
- MAPM value;
+ Number value;
int32 position;
};
@@ -198,13 +199,8 @@ class CLanguageExpressionEvaluator::Tokenizer {
fCurrentChar(NULL),
fCurrentToken(),
fReuseToken(false),
- fHexSupport(false)
- {
- }
-
- void SetSupportHexInput(bool enabled)
+ fType(B_INT32_TYPE)
{
- fHexSupport = enabled;
}
void SetTo(const char* string)
@@ -215,6 +211,11 @@ class CLanguageExpressionEvaluator::Tokenizer {
fReuseToken = false;
}
+ void SetType(type_code type)
+ {
+ fType = type;
+ }
+
const Token& NextToken()
{
if (fCurrentToken.type == TOKEN_END_OF_LINE)
@@ -235,7 +236,7 @@ class CLanguageExpressionEvaluator::Tokenizer {
bool decimal = *fCurrentChar == '.' || *fCurrentChar == ',';
if (decimal || isdigit(*fCurrentChar)) {
- if (fHexSupport && *fCurrentChar == '0' &&
fCurrentChar[1] == 'x')
+ if (*fCurrentChar == '0' && fCurrentChar[1] == 'x')
return _ParseHexNumber();
BString temp;
@@ -297,7 +298,7 @@ class CLanguageExpressionEvaluator::Tokenizer {
fCurrentToken = Token(begin, length, _CurrentPos() -
length,
TOKEN_CONSTANT);
- fCurrentToken.value = temp.String();
+ fCurrentToken.value.SetTo(fType, temp.String());
} else if (isalpha(*fCurrentChar) && *fCurrentChar != 'x') {
const char* begin = fCurrentChar;
while (*fCurrentChar != 0 && (isalpha(*fCurrentChar)
@@ -331,13 +332,6 @@ class CLanguageExpressionEvaluator::Tokenizer {
type = TOKEN_SLASH;
break;
- case 'x':
- if (!fHexSupport) {
- type = TOKEN_STAR;
- break;
- }
- // fall through
-
default:
throw
ParseException("unexpected character",
_CurrentPos());
@@ -367,8 +361,14 @@ class CLanguageExpressionEvaluator::Tokenizer {
break;
case '*':
- type = TOKEN_STAR;
- length = 1;
+ if (Peek() == '*') {
+ type = TOKEN_POWER;
+ length = 2;
+ }
+ else {
+ type = TOKEN_STAR;
+ length = 1;
+ }
break;
case '/':
@@ -382,7 +382,7 @@ class CLanguageExpressionEvaluator::Tokenizer {
break;
case '^':
- type = TOKEN_POWER;
+ type = TOKEN_BITWISE_XOR;
length = 1;
break;
@@ -497,18 +497,7 @@ class CLanguageExpressionEvaluator::Tokenizer {
fCurrentToken = Token(begin, length, _CurrentPos() - length,
TOKEN_CONSTANT);
- // MAPM has no conversion from long long, so we need to
improvise.
- uint64 value = strtoll(fCurrentToken.string.String(), NULL, 0);
- if (value <= 0x7fffffff) {
- fCurrentToken.value = (long)value;
- } else {
- fCurrentToken.value = (int)(value >> 60);
- fCurrentToken.value *= 1 << 30;
- fCurrentToken.value += (int)((value >> 30) &
0x3fffffff);
- fCurrentToken.value *= 1 << 30;
- fCurrentToken.value += (int)(value& 0x3fffffff);
- }
-
+ fCurrentToken.value.SetTo(fType, fCurrentToken.string.String(),
16);
return fCurrentToken;
}
@@ -521,7 +510,7 @@ class CLanguageExpressionEvaluator::Tokenizer {
const char* fCurrentChar;
Token fCurrentToken;
bool fReuseToken;
- bool fHexSupport;
+ type_code fType;
};
@@ -537,80 +526,22 @@
CLanguageExpressionEvaluator::~CLanguageExpressionEvaluator()
}
-void
-CLanguageExpressionEvaluator::SetSupportHexInput(bool enabled)
-{
- fTokenizer->SetSupportHexInput(enabled);
-}
-
-
-BString
-CLanguageExpressionEvaluator::Evaluate(const char* expressionString)
-{
- fTokenizer->SetTo(expressionString);
-
- MAPM value = _ParseBinary();
- Token token = fTokenizer->NextToken();
- if (token.type != TOKEN_END_OF_LINE)
- throw ParseException("parse error", token.position);
-
- if (value == 0)
- return BString("0");
-
- char* buffer = value.toFixPtStringExp(kMaxDecimalPlaces, '.', 0, 0);
- if (buffer == NULL)
- throw ParseException("out of memory", 0);
-
- // remove surplus zeros
- int32 lastChar = strlen(buffer) - 1;
- if (strchr(buffer, '.')) {
- while (buffer[lastChar] == '0')
- lastChar--;
- if (buffer[lastChar] == '.')
- lastChar--;
- }
-
- BString result(buffer, lastChar + 1);
- free(buffer);
- return result;
-}
-
-
-int64
-CLanguageExpressionEvaluator::EvaluateToInt64(const char* expressionString)
-{
- fTokenizer->SetTo(expressionString);
-
- MAPM value = _ParseBinary();
- Token token = fTokenizer->NextToken();
- if (token.type != TOKEN_END_OF_LINE)
- throw ParseException("parse error", token.position);
-
- char buffer[128];
- value.toIntegerString(buffer);
-
- return strtoll(buffer, NULL, 0);
-}
-
-
-double
-CLanguageExpressionEvaluator::EvaluateToDouble(const char* expressionString)
+Number
+CLanguageExpressionEvaluator::Evaluate(const char* expressionString, type_code
type)
{
+ fTokenizer->SetType(type);
fTokenizer->SetTo(expressionString);
- MAPM value = _ParseBinary();
+ Number value = _ParseBinary();
Token token = fTokenizer->NextToken();
if (token.type != TOKEN_END_OF_LINE)
throw ParseException("parse error", token.position);
- char buffer[1024];
- value.toString(buffer, sizeof(buffer) - 4);
-
- return strtod(buffer, NULL);
+ return value;
}
-MAPM
+Number
CLanguageExpressionEvaluator::_ParseBinary()
{
return _ParseSum();
@@ -637,20 +568,20 @@ CLanguageExpressionEvaluator::_ParseBinary()
}
-MAPM
+Number
CLanguageExpressionEvaluator::_ParseSum()
{
// TODO: check isnan()...
- MAPM value = _ParseProduct();
+ Number value = _ParseProduct();
while (true) {
Token token = fTokenizer->NextToken();
switch (token.type) {
case TOKEN_PLUS:
- value = value + _ParseProduct();
+ value += _ParseProduct();
break;
case TOKEN_MINUS:
- value = value - _ParseProduct();
+ value -= _ParseProduct();
break;
default:
@@ -661,66 +592,86 @@ CLanguageExpressionEvaluator::_ParseSum()
}
-MAPM
+Number
CLanguageExpressionEvaluator::_ParseProduct()
{
- // TODO: check isnan()...
- MAPM value = _ParsePower();
+ Number value = _ParsePower();
while (true) {
Token token = fTokenizer->NextToken();
switch (token.type) {
case TOKEN_STAR:
- value = value * _ParsePower();
+ value *= _ParsePower();
break;
case TOKEN_SLASH:
{
- MAPM rhs = _ParsePower();
- if (rhs == MAPM(0))
+ Number rhs = _ParsePower();
+ if (rhs == Number(fCurrentType, 0))
throw ParseException("division by
zero", token.position);
- value = value / rhs;
+ value /= rhs;
break;
}
case TOKEN_MODULO:
{
- MAPM rhs = _ParsePower();
- if (rhs == MAPM(0))
+ Number rhs = _ParsePower();
+ if (rhs == Number())
throw ParseException("modulo by zero",
token.position);
- value = value % rhs;
+ value %= rhs;
break;
}
case TOKEN_LOGICAL_AND:
- value = (value != MAPM(0) && _ParsePower() !=
MAPM(0));
+ {
+ Number zero(BVariant(0L));
+ value.SetTo(BVariant((int32)((value != zero)
+ && (_ParsePower() != zero))));
+
break;
+ }
case TOKEN_LOGICAL_OR:
- value = (value != MAPM(0) || _ParsePower() !=
MAPM(0));
+ {
+ Number zero(BVariant(0L));
+ value.SetTo(BVariant((int32)((value != zero)
+ || (_ParsePower() != zero))));
+ break;
+ }
+
+ case TOKEN_BITWISE_AND:
+ value &= _ParsePower();
+ break;
+
+ case TOKEN_BITWISE_OR:
+ value |= _ParsePower();
+ break;
+
+ case TOKEN_BITWISE_XOR:
+ value ^= _ParsePower();
break;
case TOKEN_EQ:
- value = (value == _ParsePower());
+ value.SetTo(BVariant((int32)(value ==
_ParsePower())));
break;
case TOKEN_NE:
- value = (value != _ParsePower());
+ value.SetTo(BVariant((int32)(value !=
_ParsePower())));
break;
case TOKEN_GT:
- value = (value > _ParsePower());
+ value.SetTo(BVariant((int32)(value >
_ParsePower())));
break;
case TOKEN_GE:
- value = (value >= _ParsePower());
+ value.SetTo(BVariant((int32)(value >=
_ParsePower())));
break;
case TOKEN_LT:
- value = (value < _ParsePower());
+ value.SetTo(BVariant((int32)(value <
_ParsePower())));
break;
case TOKEN_LE:
- value = (value <= _ParsePower());
+ value.SetTo(BVariant((int32)(value <=
_ParsePower())));
break;
default:
@@ -731,10 +682,10 @@ CLanguageExpressionEvaluator::_ParseProduct()
}
-MAPM
+Number
CLanguageExpressionEvaluator::_ParsePower()
{
- MAPM value = _ParseUnary();
+ Number value = _ParseUnary();
while (true) {
Token token = fTokenizer->NextToken();
@@ -742,12 +693,16 @@ CLanguageExpressionEvaluator::_ParsePower()
fTokenizer->RewindToken();
return value;
}
- value = value.pow(_ParseUnary());
+
+ Number power = _ParseUnary();
+ Number temp = value;
+ for (int32 powerValue = power.GetValue().ToInt32(); powerValue
> 1; powerValue--)
+ value *= temp;
}
}
-MAPM
+Number
CLanguageExpressionEvaluator::_ParseUnary()
{
Token token = fTokenizer->NextToken();
@@ -761,13 +716,11 @@ CLanguageExpressionEvaluator::_ParseUnary()
case TOKEN_MINUS:
return -_ParseUnary();
- case TOKEN_BITWISE_AND:
- case TOKEN_BITWISE_OR:
case TOKEN_BITWISE_NOT:
- throw ParseException("Unimplemented bitwise operator",
token.position);
+ return ~_ParseUnary();
case TOKEN_LOGICAL_NOT:
- return MAPM(_ParseUnary() == 0);
+ return Number((int32)(_ParseUnary() ==
Number(BVariant(0L))));
case TOKEN_IDENTIFIER:
return _ParseIdentifier();
@@ -777,7 +730,7 @@ CLanguageExpressionEvaluator::_ParseUnary()
return _ParseAtom();
}
- return MAPM(0);
+ return Number();
}
@@ -785,21 +738,21 @@ struct Function {
const char* name;
int argumentCount;
void* function;
- MAPM value;
+ Number value;
};
-MAPM
+Number
CLanguageExpressionEvaluator::_ParseIdentifier()
{
throw ParseException("Identifiers not implemented", 0);
- return MAPM(0);
+ return Number();
}
void
-CLanguageExpressionEvaluator::_InitArguments(MAPM values[], int32
argumentCount)
+CLanguageExpressionEvaluator::_InitArguments(Number values[], int32
argumentCount)
{
_EatToken(TOKEN_OPENING_BRACKET);
@@ -810,7 +763,7 @@ CLanguageExpressionEvaluator::_InitArguments(MAPM values[],
int32 argumentCount)
}
-MAPM
+Number
CLanguageExpressionEvaluator::_ParseAtom()
{
Token token = fTokenizer->NextToken();
@@ -824,7 +777,7 @@ CLanguageExpressionEvaluator::_ParseAtom()
_EatToken(TOKEN_OPENING_BRACKET);
- MAPM value = _ParseBinary();
+ Number value = _ParseBinary();
_EatToken(TOKEN_CLOSING_BRACKET);
diff --git
a/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.h
b/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.h
index b87a887..d016178 100644
---
a/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.h
+++
b/src/apps/debugger/source_language/expression_evaluators/CLanguageExpressionEvaluator.h
@@ -34,7 +34,7 @@ class ParseException {
};
struct Function;
-class MAPM;
+class Number;
class CLanguageExpressionEvaluator {
@@ -42,30 +42,28 @@ class CLanguageExpressionEvaluator {
CLanguageExpressionEvaluator();
~CLanguageExpressionEvaluator();
- void SetSupportHexInput(bool
enabled);
-
- BString Evaluate(const char*
expressionString);
- int64 EvaluateToInt64(const
char* expressionString);
- double EvaluateToDouble(const
char* expressionString);
+ Number Evaluate(const char*
expressionString,
+
type_code type);
private:
struct Token;
class Tokenizer;
private:
- MAPM _ParseBinary();
- MAPM _ParseSum();
- MAPM _ParseProduct();
- MAPM _ParsePower();
- MAPM _ParseUnary();
- MAPM _ParseIdentifier();
- void _InitArguments(MAPM
values[],
+ Number _ParseBinary();
+ Number _ParseSum();
+ Number _ParseProduct();
+ Number _ParsePower();
+ Number _ParseUnary();
+ Number _ParseIdentifier();
+ void _InitArguments(Number
values[],
int32
argumentCount);
- MAPM _ParseAtom();
+ Number _ParseAtom();
void _EatToken(int32 type);
Tokenizer* fTokenizer;
+ type_code fCurrentType;
};
#endif // C_LANGUAGE_EXPRESSION_EVALUATOR_H
diff --git
a/src/apps/debugger/user_interface/gui/team_window/ExpressionEvaluationWindow.cpp
b/src/apps/debugger/user_interface/gui/team_window/ExpressionEvaluationWindow.cpp
index 1e29850..4042e48 100644
---
a/src/apps/debugger/user_interface/gui/team_window/ExpressionEvaluationWindow.cpp
+++
b/src/apps/debugger/user_interface/gui/team_window/ExpressionEvaluationWindow.cpp
@@ -124,7 +124,7 @@ ExpressionEvaluationWindow::MessageReceived(BMessage*
message)
Value* value = NULL;
BString outputText;
status_t error = fLanguage->EvaluateExpression(
- fExpressionInput->TextView()->Text(), value);
+ fExpressionInput->TextView()->Text(),
B_INT64_TYPE, value);
if (error != B_OK) {
if (value != NULL)
value->ToString(outputText);
############################################################################
Revision: hrev48119
Commit: 1b629877b1ee4c31f8d4eaed00d253abccd087f5
URL: http://cgit.haiku-os.org/haiku/commit/?id=1b62987
Author: Rene Gollent <rene@xxxxxxxxxxx>
Date: Mon Oct 27 15:51:00 2014 UTC
Debugger: Cleanups.
- Remove dependency on MAPM/ExpressionParser. Consequently also adjust
CliDumpMemoryCommand, InspectorWindow and WatchPromptWindow to use
CLanguageExpressionEvaluator for address input evaluation.
----------------------------------------------------------------------------
diff --git a/src/apps/debugger/Jamfile b/src/apps/debugger/Jamfile
index 3c73006..9b3c91a 100644
--- a/src/apps/debugger/Jamfile
+++ b/src/apps/debugger/Jamfile
@@ -6,7 +6,6 @@ UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ]
: true ;
UseHeaders [ FDirName
$(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
system kernel ] ;
-UseLibraryHeaders mapm ;
UsePrivateHeaders app debug interface kernel package shared libroot ;
UsePrivateSystemHeaders ;
@@ -358,8 +357,6 @@ Application Debugger :
<bin>debug_utils.a
libcolumnlistview.a
libshared.a
- libexpression_parser.a
- libmapm.a
libedit.a
libncurses.a
diff --git
a/src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp
b/src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp
index 50899f1..e18fcf2 100644
--- a/src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp
+++ b/src/apps/debugger/user_interface/cli/commands/CliDumpMemoryCommand.cpp
@@ -1,7 +1,7 @@
/*
* Copyright 2009-2011, Ingo Weinhold, ingo_weinhold@xxxxxx.
* Copyright 2002-2010, Axel Dörfler, axeld@xxxxxxxxxxxxxxxx.
- * Copyright 2012, Rene Gollent, rene@xxxxxxxxxxx.
+ * Copyright 2012-2014, Rene Gollent, rene@xxxxxxxxxxx.
* Distributed under the terms of the MIT License.
*
* Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
@@ -15,9 +15,10 @@
#include <stdio.h>
#include <AutoLocker.h>
-#include <ExpressionParser.h>
+#include "CLanguageExpressionEvaluator.h"
#include "CliContext.h"
+#include "Number.h"
#include "Team.h"
#include "TeamMemoryBlock.h"
#include "UiUtils.h"
@@ -42,12 +43,11 @@ CliDumpMemoryCommand::Execute(int argc, const char* const*
argv,
return;
}
+ CLanguageExpressionEvaluator evaluator;
target_addr_t address;
- ExpressionParser parser;
- parser.SetSupportHexInput(true);
-
try {
- address = parser.EvaluateToInt64(argv[1]);
+ Number value = evaluator.Evaluate(argv[1], B_UINT64_TYPE);
+ address = value.GetValue().ToUInt64();
} catch(...) {
printf("Error parsing address/expression.\n");
return;
diff --git
a/src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp
b/src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp
index b64e804..3c29e44 100644
--- a/src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp
+++ b/src/apps/debugger/user_interface/gui/inspector_window/InspectorWindow.cpp
@@ -16,12 +16,12 @@
#include <ScrollView.h>
#include <TextControl.h>
-#include <ExpressionParser.h>
-
#include "Architecture.h"
+#include "CLanguageExpressionEvaluator.h"
#include "GuiTeamUiSettings.h"
#include "MemoryView.h"
#include "MessageCodes.h"
+#include "Number.h"
#include "Team.h"
#include "UserInterface.h"
@@ -199,12 +199,14 @@ InspectorWindow::MessageReceived(BMessage* message)
target_addr_t address = 0;
bool addressValid = false;
if (message->FindUInt64("address", &address) != B_OK) {
- ExpressionParser parser;
- parser.SetSupportHexInput(true);
+ CLanguageExpressionEvaluator evaluator;
const char* addressExpression =
fAddressInput->Text();
BString errorMessage;
try {
- address =
parser.EvaluateToInt64(addressExpression);
+ Number value;
+ value =
evaluator.Evaluate(addressExpression,
+ B_INT64_TYPE);
+ address = value.GetValue().ToUInt64();
} catch(ParseException parseError) {
errorMessage.SetToFormat("Failed to
parse address: %s",
parseError.message.String());
diff --git
a/src/apps/debugger/user_interface/gui/team_window/WatchPromptWindow.cpp
b/src/apps/debugger/user_interface/gui/team_window/WatchPromptWindow.cpp
index 4bef8b2..bdeffcf 100644
--- a/src/apps/debugger/user_interface/gui/team_window/WatchPromptWindow.cpp
+++ b/src/apps/debugger/user_interface/gui/team_window/WatchPromptWindow.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2012, Rene Gollent, rene@xxxxxxxxxxx.
+ * Copyright 2012-2014, Rene Gollent, rene@xxxxxxxxxxx.
* Distributed under the terms of the MIT License.
*/
#include "WatchPromptWindow.h"
@@ -13,10 +13,10 @@
#include <String.h>
#include <TextControl.h>
-#include <ExpressionParser.h>
-
#include "Architecture.h"
+#include "CLanguageExpressionEvaluator.h"
#include "MessageCodes.h"
+#include "Number.h"
#include "UserInterface.h"
#include "Watchpoint.h"
@@ -143,12 +143,15 @@ WatchPromptWindow::MessageReceived(BMessage* message)
{
target_addr_t address = 0;
int32 length = 0;
- ExpressionParser parser;
- parser.SetSupportHexInput(true);
+ CLanguageExpressionEvaluator evaluator;
BString errorMessage;
try {
- address =
parser.EvaluateToInt64(fAddressInput->Text());
- length =
(int32)parser.EvaluateToInt64(fLengthInput->Text());
+ Number value =
evaluator.Evaluate(fAddressInput->Text(),
+ B_UINT64_TYPE);
+ address = value.GetValue().ToUInt64();
+ value = evaluator.Evaluate(fLengthInput->Text(),
+ B_INT32_TYPE);
+ length = value.GetValue().ToInt32();
} catch(ParseException parseError) {
errorMessage.SetToFormat("Failed to parse data:
%s",
parseError.message.String());
Other related posts:
- » [haiku-commits] haiku: hrev48119 - in src/apps/debugger: types source_language/expression_evaluators source_language user_interface/gui - anevilyak
