From 138e955cfd656ccfa9f83db893a827d25a2dc66a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89milie=20Feral?= Date: Mon, 29 Oct 2018 17:49:14 +0100 Subject: [PATCH] [poincare] Factorize Symbol and Function code in SymbolAbstract --- poincare/include/poincare/function.h | 3 +-- poincare/include/poincare/symbol.h | 3 +-- poincare/include/poincare/symbol_abstract.h | 9 +++++++- poincare/src/function.cpp | 22 +------------------- poincare/src/symbol.cpp | 21 +------------------ poincare/src/symbol_abstract.cpp | 23 +++++++++++++++++---- 6 files changed, 31 insertions(+), 50 deletions(-) diff --git a/poincare/include/poincare/function.h b/poincare/include/poincare/function.h index 9969e1243..1fff8a28b 100644 --- a/poincare/include/poincare/function.h +++ b/poincare/include/poincare/function.h @@ -12,8 +12,6 @@ public: const char * name() const override { return m_name; } // TreeNode - void initToMatchSize(size_t goalSize) override; - size_t size() const override; int numberOfChildren() const override { return 1; } //TODO allow any number of children? Needs templating #if POINCARE_TREE_LOG virtual void logNodeName(std::ostream & stream) const override { @@ -33,6 +31,7 @@ public: private: char m_name[0]; // MUST be the last member variable + size_t nodeSize() const override { return sizeof(FunctionNode); } VariableContext xContext(Context & parentContext) const; // Layout Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h index c4393b191..b65a0aaeb 100644 --- a/poincare/include/poincare/symbol.h +++ b/poincare/include/poincare/symbol.h @@ -10,8 +10,6 @@ public: const char * name() const override { return m_name; } // TreeNode - void initToMatchSize(size_t goalSize) override; - size_t size() const override; int numberOfChildren() const override { return 0; } #if POINCARE_TREE_LOG virtual void logNodeName(std::ostream & stream) const override { @@ -47,6 +45,7 @@ public: private: char m_name[0]; // MUST be the last member variable + size_t nodeSize() const override { return sizeof(SymbolNode); } template Evaluation templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; bool isSymbolChar(char c) const { const char symbolName[2] = {c, 0}; return strcmp(m_name, symbolName) == 0; } }; diff --git a/poincare/include/poincare/symbol_abstract.h b/poincare/include/poincare/symbol_abstract.h index 5735da16b..692fa1283 100644 --- a/poincare/include/poincare/symbol_abstract.h +++ b/poincare/include/poincare/symbol_abstract.h @@ -28,6 +28,8 @@ class SymbolAbstractNode : public ExpressionNode { public: virtual const char * name() const = 0; void setName(const char * newName, int length); + size_t size() const override; + void initToMatchSize(size_t goalSize) override; // ExpressionNode int simplificationOrderSameType(const ExpressionNode * e, bool canBeInterrupted) const override; @@ -43,10 +45,13 @@ public: #endif protected: - void initName(size_t nameSize); + virtual size_t nodeSize() const = 0; }; class SymbolAbstract : public Expression { + friend class Function; + friend class Symbol; + friend class SymbolAbstractNode; public: const char * name() const { return node()->name(); } static size_t TruncateExtension(char * dst, const char * src, size_t len); @@ -54,6 +59,8 @@ public: protected: SymbolAbstract(const SymbolAbstractNode * node) : Expression(node) {} SymbolAbstractNode * node() const { return static_cast(Expression::node()); } +private: + static size_t AlignedNodeSize(size_t nameLength, size_t nodeSize); }; } diff --git a/poincare/src/function.cpp b/poincare/src/function.cpp index d7fa5c3cb..19b9a659a 100644 --- a/poincare/src/function.cpp +++ b/poincare/src/function.cpp @@ -1,5 +1,4 @@ #include -#include #include #include #include @@ -10,25 +9,6 @@ namespace Poincare { -/* TreePool uses adresses and sizes that are multiples of 4 in order to make - * node moves faster.*/ -static size_t NodeSize(size_t nameLength) { - return Helpers::AlignedSize(sizeof(FunctionNode)+nameLength+1, 4); -} - -void FunctionNode::initToMatchSize(size_t goalSize) { - // TODO Factorize with symbol - assert(goalSize != sizeof(FunctionNode)); - assert(goalSize > sizeof(FunctionNode)); - size_t nameSize = goalSize - sizeof(FunctionNode); - SymbolAbstractNode::initName(nameSize); - assert(size() == goalSize); -} - -size_t FunctionNode::size() const { - return NodeSize(strlen(m_name)); -} - Expression FunctionNode::replaceSymbolWithExpression(const SymbolAbstract & symbol, const Expression & expression) { return Function(this).replaceSymbolWithExpression(symbol, expression); } @@ -108,7 +88,7 @@ Evaluation FunctionNode::templatedApproximate(Context& context, Preferences:: } Function::Function(const char * name) : - Function(TreePool::sharedPool()->createTreeNode(NodeSize(strlen(name)))) + Function(TreePool::sharedPool()->createTreeNode(SymbolAbstract::AlignedNodeSize(strlen(name), sizeof(FunctionNode)))) { static_cast(Expression::node())->setName(name, strlen(name)); } diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp index 432160f32..54b1d36bf 100644 --- a/poincare/src/symbol.cpp +++ b/poincare/src/symbol.cpp @@ -1,7 +1,6 @@ #include #include #include -#include #include #include #include @@ -15,24 +14,6 @@ namespace Poincare { constexpr char Symbol::k_ans[]; -void SymbolNode::initToMatchSize(size_t goalSize) { - assert(goalSize != sizeof(SymbolNode)); - assert(goalSize > sizeof(SymbolNode)); - size_t nameSize = goalSize - sizeof(SymbolNode); - SymbolAbstractNode::initName(nameSize); - assert(size() == goalSize); -} - -/* TreePool uses adresses and sizes that are multiples of 4 in order to make - * node moves faster.*/ -static size_t NodeSize(size_t nameLength) { - return Helpers::AlignedSize(sizeof(SymbolNode)+nameLength+1, 4); -} - -size_t SymbolNode::size() const { - return NodeSize(strlen(m_name)); -} - ExpressionNode::Sign SymbolNode::sign() const { /* TODO: Maybe, we will want to know that from a context given in parameter: if (context.expressionForSymbol(this) != nullptr) { @@ -165,7 +146,7 @@ Evaluation SymbolNode::templatedApproximate(Context& context, Preferences::An return e.approximateToEvaluation(context, angleUnit); } -Symbol::Symbol(const char * name, int length) : SymbolAbstract(TreePool::sharedPool()->createTreeNode(NodeSize(length))) { +Symbol::Symbol(const char * name, int length) : SymbolAbstract(TreePool::sharedPool()->createTreeNode(SymbolAbstract::AlignedNodeSize(length, sizeof(SymbolNode)))) { node()->setName(name, length); } diff --git a/poincare/src/symbol_abstract.cpp b/poincare/src/symbol_abstract.cpp index dbcfebd79..5e038a275 100644 --- a/poincare/src/symbol_abstract.cpp +++ b/poincare/src/symbol_abstract.cpp @@ -1,4 +1,5 @@ #include +#include #include namespace Poincare { @@ -7,17 +8,31 @@ void SymbolAbstractNode::setName(const char * newName, int length) { strlcpy(const_cast(name()), newName, length+1); } -int SymbolAbstractNode::simplificationOrderSameType(const ExpressionNode * e, bool canBeInterrupted) const { - assert(e->type() == Type::Symbol || e->type() == Type::Function); - return strcmp(name(), static_cast(e)->name()); +size_t SymbolAbstractNode::size() const { + return SymbolAbstract::AlignedNodeSize(strlen(name()), nodeSize()); } -void SymbolAbstractNode::initName(size_t nameSize) { +void SymbolAbstractNode::initToMatchSize(size_t goalSize) { + assert(goalSize != nodeSize()); + assert(goalSize > nodeSize()); + size_t nameSize = goalSize - nodeSize(); char * modifiableName = const_cast(name()); for (size_t i = 0; i < nameSize - 1; i++) { modifiableName[i] = 'a'; } modifiableName[nameSize-1] = 0; + assert(size() == goalSize); +} + +int SymbolAbstractNode::simplificationOrderSameType(const ExpressionNode * e, bool canBeInterrupted) const { + assert(e->type() == Type::Symbol || e->type() == Type::Function); + return strcmp(name(), static_cast(e)->name()); +} + +/* TreePool uses adresses and sizes that are multiples of 4 in order to make + * node moves faster.*/ +size_t SymbolAbstract::AlignedNodeSize(size_t nameLength, size_t nodeSize) { + return Helpers::AlignedSize(nodeSize+nameLength+1, 4); } size_t SymbolAbstract::TruncateExtension(char * dst, const char * src, size_t len) {