day's work

diff --git a/rplexpr/rplasclasses.cpp b/rplexpr/rplasclasses.cpp
index 25f29e9caad36e99fca6b63f966f25ff352e1f5d..72f2a60a421a0e73fcb7890ebf94ddd4e3955998 100644 (file)
--- a/rplexpr/rplasclasses.cpp
+++ b/rplexpr/rplasclasses.cpp
@@ -17,6 +17,7 @@ RplASInteger RplASInteger::m_instance;
 RplASString RplASString::m_instance;
 RplASBoolean RplASBoolean::m_instance;
 RplASVoid RplASVoid::m_instance;
+RplASFormula RplASFormula::m_instance;
 
 /** @class RplSymbolSpace rplastree.hpp "rplexpr/rplastree.hpp"
  *
@@ -66,6 +67,7 @@ RplSymbolSpace::RplSymbolSpace(RplSymbolSpace::SymbolSpaceType type,
         m_classes[RplASList::m_instance.name()] = &RplASList::m_instance;
         m_classes[RplASMap::m_instance.name()] = &RplASMap::m_instance;
         m_classes[RplASVoid::m_instance.name()] = &RplASVoid::m_instance;
+        m_classes[RplASFormula::m_instance.name()] = &RplASFormula::m_instance;
     }
 }
 
@@ -488,11 +490,11 @@ RplASList::RplASList() :
  */
 void* RplASList::newValueInstance(void* source) const
 {
-    ListValueType* rc = new ListValueType();
+    ListOfVariants* rc = new ListOfVariants();
     if (source != NULL){
-        ListValueType* source2 = (ListValueType*) source;
+        ListOfVariants* source2 = (ListOfVariants*) source;
         rc->reserve(source2->size());
-        ListValueType::iterator it;
+        ListOfVariants::iterator it;
         for (it = source2->begin();
                 it != source2->end();
                 it++){
@@ -512,7 +514,7 @@ void* RplASList::newValueInstance(void* source) const
  */
 void RplASList::destroyValueInstance(void* object) const
 {
-    delete static_cast<ListValueType*>(object);
+    delete static_cast<ListOfVariants*>(object);
 }
 
 /**
@@ -526,7 +528,7 @@ bool RplASList::boolValueOf(void* object) const
 {
     bool rc = false;
     if (object != NULL){
-        ListValueType* list = static_cast<ListValueType*>(object);
+        ListOfVariants* list = static_cast<ListOfVariants*>(object);
         if (list == NULL)
             throw RplException("RplASList.boolValueOf(): not a list");
         rc = ! list->empty();
@@ -545,8 +547,8 @@ QString RplASList::toString(void* object, int maxLength) const
     QString rc;
     rc.reserve(maxLength);
     rc += "[";
-    ListValueType* list = reinterpret_cast<ListValueType*>(object);
-    ListValueType::iterator it;
+    ListOfVariants* list = reinterpret_cast<ListOfVariants*>(object);
+    ListOfVariants::iterator it;
     bool first = true;
     for(it = list->begin(); it != list->end(); it++){
         if (first)
@@ -767,3 +769,59 @@ QString RplASVoid::toString(void*, int) const
 {
     return QString("");
 }
+
+/** @class RplASFormula rplastree.hpp "rplexpr/rplastree.hpp"
+ *
+ * @brief Implements a data type representing a calculated value.
+ */
+
+RplASFormula::RplASFormula() :
+    RplASClass("Formula")
+{
+}
+
+/**
+ * @brief Instantiates a new object.
+ *
+ * In this case we do nothing.
+ *
+ * @param source    ignored
+ * @return
+ */
+void*RplASFormula::newValueInstance(void*) const
+{
+    return NULL;
+}
+
+/**
+ * @brief Destroys an object created by newValueInstance.
+ *
+ * In this case we do nothing.
+ *
+ * @param object    not used
+ */
+void RplASFormula::destroyValueInstance(void*) const
+{
+}
+
+/**
+ * @brief Returns the bool value of the given object
+ * @param object    ignored
+ * @return          false
+ */
+bool RplASFormula::boolValueOf(void*) const
+{
+    return false;
+}
+
+/**
+ * @brief Converts the object into a string.
+ *
+ * @param object    ignored
+ * @param maxLength ignored
+ * @return          the empty string
+ */
+QString RplASFormula::toString(void*, int) const
+{
+    return QString("");
+}

diff --git a/rplexpr/rplasclasses.hpp b/rplexpr/rplasclasses.hpp
index f4bf4335c9420d56314a1c5c59e88d0814f5ed9c..1eca8440653f66ee220d3a1a840ccdc50e19b19d 100644 (file)
--- a/rplexpr/rplasclasses.hpp
+++ b/rplexpr/rplasclasses.hpp
@@ -113,7 +113,7 @@ public:
 
 class RplASList : public RplASClass {
 public:
-    typedef QList<RplASVariant*> ListValueType;
+    typedef QList<RplASVariant*> ListOfVariants;
 public:
     RplASList();
 public:
@@ -151,5 +151,17 @@ public:
     static RplASVoid m_instance;
 };
 
+class RplASFormula : public RplASClass {
+public:
+    RplASFormula();
+public:
+    void* newValueInstance(void* source = NULL) const;
+    void destroyValueInstance(void* object) const;
+    virtual bool boolValueOf(void* object) const;
+    virtual QString toString(void *object, int maxLength = 80) const;
+public:
+    static RplASFormula m_instance;
+};
+
 
 #endif // RPLASCLASSES_HPP

diff --git a/rplexpr/rplastree.cpp b/rplexpr/rplastree.cpp
index b6f6c5f89cb2418c3c8ca6c4783588b835509b51..3faf3055268976da1e0821801e1db35667380b1b 100644 (file)
--- a/rplexpr/rplastree.cpp
+++ b/rplexpr/rplastree.cpp
@@ -79,7 +79,7 @@ RplASException::RplASException() :
  *
  */
 RplASVariant::RplASVariant() :
-    m_dataType(DT_UNDEF),
+    m_variantType(VT_UNDEF),
     m_flags(VF_UNDEF),
     // m_value(),
     m_class(NULL)
@@ -91,7 +91,7 @@ RplASVariant::RplASVariant() :
 RplASVariant::~RplASVariant()
 {
     destroyValue();
-    m_dataType = DT_UNDEF;
+    m_variantType = VT_UNDEF;
 }
 
 /**
@@ -99,7 +99,7 @@ RplASVariant::~RplASVariant()
  * @param source    the source to copy
  */
 RplASVariant::RplASVariant(const RplASVariant& source):
-    m_dataType(source.m_dataType),
+    m_variantType(source.m_variantType),
     m_flags(source.m_flags),
     // m_value
     m_class(source.m_class)
@@ -116,7 +116,7 @@ RplASVariant::RplASVariant(const RplASVariant& source):
 RplASVariant&RplASVariant::operator=(const RplASVariant& source)
 {
     destroyValue();
-    m_dataType = source.m_dataType;
+    m_variantType = source.m_variantType;
     m_flags = source.m_flags;
     m_class = source.m_class;
     copyValue(source);
@@ -129,18 +129,18 @@ RplASVariant&RplASVariant::operator=(const RplASVariant& source)
  */
 void RplASVariant::copyValue(const RplASVariant& source)
 {
-    switch(source.m_dataType)
+    switch(source.m_variantType)
     {
-    case DT_BOOL:
+    case VT_BOOL:
         m_value.m_bool = source.m_value.m_bool;
         break;
-    case DT_FLOAT:
+    case VT_FLOAT:
         m_value.m_float = source.m_value.m_float;
         break;
-    case DT_INTEGER:
+    case VT_INTEGER:
         m_value.m_int = source.m_value.m_int;
         break;
-    case DT_UNDEF:
+    case VT_UNDEF:
         break;
     default:
         m_value.m_object = m_class->newValueInstance(source.m_value.m_object);
@@ -152,12 +152,12 @@ void RplASVariant::copyValue(const RplASVariant& source)
  */
 void RplASVariant::destroyValue()
 {
-    switch(m_dataType)
+    switch(m_variantType)
     {
-    case DT_BOOL:
-    case DT_FLOAT:
-    case DT_INTEGER:
-    case DT_UNDEF:
+    case VT_BOOL:
+    case VT_FLOAT:
+    case VT_INTEGER:
+    case VT_UNDEF:
         break;
     default:
         if ((m_flags & VF_IS_COPY) == 0)
@@ -166,6 +166,26 @@ void RplASVariant::destroyValue()
         break;
     }
 }
+/**
+ * @brief Returns the variantType of the instance.
+ *
+ * @return  the variant type
+ */
+RplASVariant::VariantType RplASVariant::variantType() const
+{
+    return m_variantType;
+}
+
+/**
+ * @brief Returns the class (data type) of the instance.
+ *
+ * @return  the variant type
+ */
+RplASClass* RplASVariant::getClass() const
+{
+    return m_class;
+}
+
 
 /**
  * @brief Returns the numeric value.
@@ -176,9 +196,9 @@ void RplASVariant::destroyValue()
  */
 qreal RplASVariant::asFloat() const
 {
-    if (m_dataType != DT_FLOAT)
+    if (m_variantType != VT_FLOAT)
         throw RplException("RplASVariant::asNumber: not a number: %d",
-                           m_dataType);
+                           m_variantType);
     return m_value.m_float;
 }
 /**
@@ -190,9 +210,9 @@ qreal RplASVariant::asFloat() const
  */
 int RplASVariant::asInt() const
 {
-    if (m_dataType != DT_INTEGER)
+    if (m_variantType != VT_INTEGER)
         throw RplException("RplASVariant::asInt: not an integer: %d",
-                           m_dataType);
+                           m_variantType);
     return m_value.m_int;
 }
 
@@ -205,9 +225,9 @@ int RplASVariant::asInt() const
  */
 bool RplASVariant::asBool() const
 {
-    if (m_dataType != DT_BOOL)
+    if (m_variantType != VT_BOOL)
         throw RplException("RplASVariant::asBool: not a boolean: %d",
-                           m_dataType);
+                           m_variantType);
     return m_value.m_bool;
 }
 
@@ -221,9 +241,9 @@ bool RplASVariant::asBool() const
  */
 void* RplASVariant::asObject(const RplASClass** clazz) const
 {
-    if (m_dataType != DT_OBJECT)
+    if (m_variantType != VT_OBJECT)
         throw RplException("RplASVariant::asObject: not an object: %d",
-                           m_dataType);
+                           m_variantType);
     if (clazz != NULL)
         *clazz = m_class;
     return m_value.m_object;
@@ -255,7 +275,7 @@ const QString* RplASVariant::asString() const
 void RplASVariant::setFloat(qreal number)
 {
     destroyValue();
-    m_dataType = DT_FLOAT;
+    m_variantType = VT_FLOAT;
     m_value.m_float = number;
     m_class = &RplASFloat::m_instance;
 }
@@ -268,7 +288,7 @@ void RplASVariant::setFloat(qreal number)
 void RplASVariant::setInt(int integer)
 {
     destroyValue();
-    m_dataType = DT_INTEGER;
+    m_variantType = VT_INTEGER;
     m_value.m_int = integer;
     m_class = &RplASInteger::m_instance;
 }
@@ -281,7 +301,7 @@ void RplASVariant::setInt(int integer)
 void RplASVariant::setBool(bool value)
 {
     destroyValue();
-    m_dataType = DT_BOOL;
+    m_variantType = VT_BOOL;
     m_value.m_bool = value;
     m_class = &RplASBoolean::m_instance;
 }
@@ -305,22 +325,22 @@ void RplASVariant::setString(const QString& string)
 QString RplASVariant::toString(int maxLength) const
 {
     QString rc;
-    switch(m_dataType)
+    switch(m_variantType)
     {
-    case DT_BOOL:
+    case VT_BOOL:
         rc = m_value.m_bool ? "True" : "False";
         break;
-    case DT_FLOAT:
+    case VT_FLOAT:
         rc.sprintf("%f", m_value.m_float);
         break;
-    case DT_INTEGER:
+    case VT_INTEGER:
         rc.sprintf("%d", m_value.m_int);
         break;
-    case DT_OBJECT:
+    case VT_OBJECT:
         rc = m_class->toString(m_value.m_object, maxLength);
         break;
     default:
-    case DT_UNDEF:
+    case VT_UNDEF:
         rc = "None";
         break;
     }
@@ -335,7 +355,7 @@ QString RplASVariant::toString(int maxLength) const
 void RplASVariant::setObject(void* object, const RplASClass* clazz)
 {
     destroyValue();
-    m_dataType = DT_OBJECT;
+    m_variantType = VT_OBJECT;
     m_value.m_object = object;
     m_class = clazz;
 }
@@ -494,6 +514,66 @@ RplASVariant& RplASConstant::value()
     return m_value;
 }
 
+/** @class RplASListConstant rplastree.hpp "rplexpr/rplastree.hpp"
+ *
+ * @brief Implements a container for constant list entries.
+ *
+ */
+
+/**
+ * @brief Constructor.
+ */
+RplASListConstant::RplASListConstant() :
+    RplASNode1(AST_LIST_CONSTANT),
+    RplASCalculable()
+{
+}
+
+/**
+ * @brief Calculates the expression.
+ *
+ * @param value     OUT: the calculated value
+ */
+void RplASListConstant::calc(RplASVariant& value)
+{
+    value = m_value;
+}
+
+/**
+ * @brief Writes the internals into a file.
+ *
+ * @param fp        target file
+ * @param indent    nesting level
+ */
+void RplASListConstant::dump(FILE* fp, int indent)
+{
+    DEFINE_TABS(indent);
+    char buffer[256];
+    fprintf(fp, "%slistConst id: %d %s\n", tabs, m_id,
+            positionStr(buffer, sizeof buffer));
+
+    RplASList::ListOfVariants* list = (RplASList::ListOfVariants*)
+            m_value.asObject();
+    QString sValue = m_value.toString(8092);
+    fprintf(fp, "%s\t%s\n", tabs, sValue.toUtf8().constData());
+}
+
+/**
+ * @brief Returns the value of the constant.
+ *
+ * This method will be used to set the value of the constant:
+ * <pre><code>RplASConstant constant;
+ * constant.value().setString("Jonny");
+ *</code></pre>
+ *
+ * @return the internal value
+ */
+RplASVariant& RplASListConstant::value()
+{
+    return m_value;
+}
+
+
 /** @class RplASNamedValue rplastree.hpp "rplexpr/rplastree.hpp"
  *
  * @brief Implements a named values, a constant or a variable
@@ -1015,14 +1095,14 @@ bool RplASCondition::calcAsBool()
     bool rc = false;
     RplASVariant value;
     calc(value);
-    switch(value.m_dataType){
-    case RplASVariant::DT_FLOAT:
+    switch(value.m_variantType){
+    case RplASVariant::VT_FLOAT:
         rc = value.m_value.m_float == 0;
         break;
-    case RplASVariant::DT_BOOL:
+    case RplASVariant::VT_BOOL:
         rc = value.m_value.m_bool;
         break;
-    case RplASVariant::DT_OBJECT:
+    case RplASVariant::VT_OBJECT:
         rc = value.m_class->boolValueOf(value.m_value.m_object);
         break;
     default:
@@ -1798,6 +1878,3 @@ RplASArgument::RplASArgument() :
     RplASNode2(AST_ARGUMENT)
 {
 }
-
-
-

diff --git a/rplexpr/rplastree.hpp b/rplexpr/rplastree.hpp
index 9d9d825b984699efdb362da9c59b50d8655b4f40..68a61836766ed9262060f45fa32bd518c4912382 100644 (file)
--- a/rplexpr/rplastree.hpp
+++ b/rplexpr/rplastree.hpp
@@ -13,6 +13,10 @@
 enum RplASItemType {
     AST_UNDEF,
     AST_CONSTANT,
+    AST_LIST_CONSTANT,
+    AST_LIST_ENTRY,
+    AST_MAP_CONSTANT,
+    AST_MAP_ENTRY,
     AST_NAMED_VALUE,
     AST_VAR_DEFINITION,
     AST_EXPR_STATEMENT,
@@ -50,12 +54,12 @@ class RplASCondition;
 
 class RplASVariant {
 public:
-    enum DataType {
-        DT_UNDEF,
-        DT_FLOAT,
-        DT_INTEGER,
-        DT_BOOL,
-        DT_OBJECT
+    enum VariantType {
+        VT_UNDEF,
+        VT_FLOAT,
+        VT_INTEGER,
+        VT_BOOL,
+        VT_OBJECT
     };
     enum VariantFlags {
         VF_UNDEF,
@@ -82,12 +86,13 @@ public:
     void setObject(void* object, const RplASClass* clazz);
     void setString(const QString& string);
     QString toString(int maxLength = 80) const;
-    QString repr() const;
+    VariantType variantType() const;
+    RplASClass* getClass() const;
 protected:
     void copyValue(const RplASVariant& source);
     void destroyValue();
 private:
-    DataType m_dataType:8;
+    VariantType m_variantType:8;
     /// bitmap of VF_... flags:
     int m_flags:8;
     union {
@@ -227,6 +232,31 @@ protected:
     RplASItem* m_child5;
 };
 
+class RplASListConstant : public RplASNode1, public RplASCalculable
+{
+public:
+    RplASListConstant();
+public:
+    virtual void calc(RplASVariant& value);
+public:
+    virtual void dump(FILE* fp, int indent);
+    RplASVariant& value();
+private:
+    RplASVariant m_value;
+};
+class RplASMapConstant : public RplASNode1, public RplASCalculable
+{
+public:
+    RplASMapConstant();
+public:
+    virtual void calc(RplASVariant& value);
+public:
+    virtual void dump(FILE* fp, int indent);
+    RplASVariant& value();
+private:
+    RplASVariant m_value;
+};
+
 class RplASNamedValue : public RplASNode1, public RplASCalculable
 {
 public: