diff --git a/poincare/include/poincare/infinity.h b/poincare/include/poincare/infinity.h index 95aa29f37..6cd6efdb9 100644 --- a/poincare/include/poincare/infinity.h +++ b/poincare/include/poincare/infinity.h @@ -49,6 +49,12 @@ public: node()->setNegative(negative); } Expression setSign(ExpressionNode::Sign s, Context & context, Preferences::AngleUnit angleUnit); + static const char * Name() { + return "inf"; + } + static int NameSize() { + return 4; + } private: InfinityNode * node() const { return static_cast(Number::node()); } }; diff --git a/poincare/src/decimal.cpp b/poincare/src/decimal.cpp index b90015b45..8e3ba1a15 100644 --- a/poincare/src/decimal.cpp +++ b/poincare/src/decimal.cpp @@ -140,11 +140,16 @@ int DecimalNode::convertToText(char * buffer, int bufferSize, Preferences::Print if (currentChar >= bufferSize-1) { return bufferSize-1; } } int mantissaLength = m.serialize(tempBuffer, PrintFloat::k_numberOfStoredSignificantDigits+1); - assert(strcmp(tempBuffer, "inf") != 0 && strcmp(tempBuffer, "-inf") != 0); + + // Assert that m is not +/-inf + assert(strcmp(tempBuffer, Infinity::Name()) != 0); + assert(!(tempBuffer[0] == '-' && strcmp(&tempBuffer[1], Infinity::Name()) == 0)); + if (strcmp(tempBuffer, Undefined::Name()) == 0) { currentChar += strlcpy(buffer+currentChar, tempBuffer, bufferSize-currentChar); return currentChar; } + /* We force scientific mode if the number of digits before the dot is superior * to the number of significant digits (ie with 4 significant digits, * 12345 -> 1.235E4 or 12340 -> 1.234E4). */ diff --git a/poincare/src/parsing/parser.cpp b/poincare/src/parsing/parser.cpp index 802e4c12e..1b52dfcfe 100644 --- a/poincare/src/parsing/parser.cpp +++ b/poincare/src/parsing/parser.cpp @@ -38,7 +38,7 @@ bool Parser::IsSpecialIdentifierName(const char * name, size_t nameLength) { // TODO Avoid special cases if possible return ( Token::CompareNonNullTerminatedName(name, nameLength, Symbol::k_ans) == 0 || - Token::CompareNonNullTerminatedName(name, nameLength, "inf") == 0 || + Token::CompareNonNullTerminatedName(name, nameLength, Infinity::Name()) == 0 || Token::CompareNonNullTerminatedName(name, nameLength, Undefined::Name()) == 0 || Token::CompareNonNullTerminatedName(name, nameLength, "u_") == 0 || Token::CompareNonNullTerminatedName(name, nameLength, "v_") == 0 || @@ -347,7 +347,7 @@ void Parser::parseSequence(Expression & leftHandSide, const char name, Token::Ty void Parser::parseSpecialIdentifier(Expression & leftHandSide) { if (m_currentToken.compareTo(Symbol::k_ans) == 0) { leftHandSide = Symbol::Ans(); - } else if (m_currentToken.compareTo("inf") == 0) { + } else if (m_currentToken.compareTo(Infinity::Name()) == 0) { leftHandSide = Infinity(false); } else if (m_currentToken.compareTo(Undefined::Name()) == 0) { leftHandSide = Undefined(); diff --git a/poincare/src/print_float.cpp b/poincare/src/print_float.cpp index 0d937091a..369d8a1ee 100644 --- a/poincare/src/print_float.cpp +++ b/poincare/src/print_float.cpp @@ -1,7 +1,8 @@ #include -#include #include +#include #include +#include #include extern "C" { #include @@ -11,8 +12,6 @@ extern "C" { #include } #include -#include -#include namespace Poincare { @@ -68,18 +67,16 @@ template int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignificantDigits, Preferences::PrintFloatMode mode) { assert(numberOfSignificantDigits > 0); if (std::isinf(f)) { + assert(Infinity::NameSize()+1 < PrintFloat::k_maxFloatBufferLength); int currentChar = 0; if (f < 0) { buffer[currentChar++] = '-'; } - buffer[currentChar++] = 'i'; - buffer[currentChar++] = 'n'; - buffer[currentChar++] = 'f'; - buffer[currentChar] = 0; - return currentChar; + strlcpy(&buffer[currentChar], Infinity::Name(), PrintFloat::k_maxFloatBufferLength-1); + return currentChar + Infinity::NameSize() - 1; } - if (std::isinf(f) || std::isnan(f)) { + if (std::isnan(f)) { assert(Undefined::NameSize() < PrintFloat::k_maxFloatBufferLength); strlcpy(buffer, Undefined::Name(), PrintFloat::k_maxFloatBufferLength); return Undefined::NameSize() - 1; diff --git a/poincare/test/convert_expression_to_text.cpp b/poincare/test/convert_expression_to_text.cpp index f584e0a9d..7656bd7b1 100644 --- a/poincare/test/convert_expression_to_text.cpp +++ b/poincare/test/convert_expression_to_text.cpp @@ -281,7 +281,7 @@ QUIZ_CASE(poincare_approximation_to_text) { assert_expression_prints_to(Float(0.0000009999999999999995), "0.000001", DecimalMode); assert_expression_prints_to(Float(-1.2345E-1), "-0.12345", DecimalMode); - assert_expression_prints_to(Float(INFINITY), "inf", DecimalMode); + assert_expression_prints_to(Float(INFINITY), Infinity::Name(), DecimalMode); assert_expression_prints_to(Float(0.0f), "0", DecimalMode); assert_expression_prints_to(Float(NAN), Undefined::Name(), DecimalMode); diff --git a/poincare/test/float.cpp b/poincare/test/float.cpp index 8a65de3c8..fbd9d6b69 100644 --- a/poincare/test/float.cpp +++ b/poincare/test/float.cpp @@ -40,7 +40,7 @@ QUIZ_CASE(poincare_float_evaluate) { assert_float_evaluates_to(Float(0.0000009999999999999995), "0.000001"); assert_float_evaluates_to(Float(-1.2345E-1), "-0.12345"); - assert_float_evaluates_to(Float(INFINITY), "inf"); + assert_float_evaluates_to(Float(INFINITY), Infinity::Name()); assert_float_evaluates_to(Float(0.0f), "0"); assert_float_evaluates_to(Float(NAN), Undefined::Name()); diff --git a/poincare/test/function.cpp b/poincare/test/function.cpp index e749aeb3d..675a196c3 100644 --- a/poincare/test/function.cpp +++ b/poincare/test/function.cpp @@ -238,11 +238,11 @@ QUIZ_CASE(poincare_function_simplify) { assert_parsed_expression_simplify_to("ceil(-1.3)", "-1"); assert_parsed_expression_simplify_to("conj(1/2)", "1/2"); assert_parsed_expression_simplify_to("quo(19,3)", "6"); - assert_parsed_expression_simplify_to("quo(19,0)", "inf"); + assert_parsed_expression_simplify_to("quo(19,0)", Infinity::Name()); assert_parsed_expression_simplify_to("quo(-19,3)", "-7"); assert_parsed_expression_simplify_to("rem(19,3)", "1"); assert_parsed_expression_simplify_to("rem(-19,3)", "2"); - assert_parsed_expression_simplify_to("rem(19,0)", "inf"); + assert_parsed_expression_simplify_to("rem(19,0)", Infinity::Name()); assert_parsed_expression_simplify_to("99!", "933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000"); assert_parsed_expression_simplify_to("factor(-10008/6895)", "-(2^3*3^2*139)/(5*7*197)"); assert_parsed_expression_simplify_to("factor(1008/6895)", "(2^4*3^2)/(5*197)"); diff --git a/poincare/test/integer.cpp b/poincare/test/integer.cpp index a3905e0f2..c5a19f493 100644 --- a/poincare/test/integer.cpp +++ b/poincare/test/integer.cpp @@ -268,5 +268,5 @@ QUIZ_CASE(poincare_integer_serialize) { assert_integer_serializes_to(Integer("2345678909876"), "2345678909876"); assert_integer_serializes_to(Integer("-2345678909876"), "-2345678909876"); assert_integer_serializes_to(MaxInteger(), MaxIntegerString()); - assert_integer_serializes_to(OverflowedInteger(), "inf"); + assert_integer_serializes_to(OverflowedInteger(), Infinity::Name()); } diff --git a/poincare/test/logarithm.cpp b/poincare/test/logarithm.cpp index 2cc1c192f..7a1d3047b 100644 --- a/poincare/test/logarithm.cpp +++ b/poincare/test/logarithm.cpp @@ -28,7 +28,7 @@ QUIZ_CASE(poincare_logarithm_simplify) { assert_parsed_expression_simplify_to("log(1,0)", "0"); assert_parsed_expression_simplify_to("log(2,0)", "0"); assert_parsed_expression_simplify_to("log(0,14)", "-inf"); - assert_parsed_expression_simplify_to("log(0,0.14)", "inf"); + assert_parsed_expression_simplify_to("log(0,0.14)", Infinity::Name()); assert_parsed_expression_simplify_to("log(0,0.14+I)", Undefined::Name()); assert_parsed_expression_simplify_to("log(2,1)", Undefined::Name()); assert_parsed_expression_simplify_to("log(x,1)", Undefined::Name()); diff --git a/poincare/test/parser.cpp b/poincare/test/parser.cpp index e9ea40e27..4f58c2ce8 100644 --- a/poincare/test/parser.cpp +++ b/poincare/test/parser.cpp @@ -267,7 +267,7 @@ QUIZ_CASE(poincare_parser_symbols_and_functions) { assert_parsed_expression_is("I", Constant(Ion::Charset::IComplex)); assert_parsed_expression_is("P", Constant(Ion::Charset::SmallPi)); assert_parsed_expression_is("X", Constant(Ion::Charset::Exponential)); - assert_parsed_expression_is("inf", Infinity(false)); + assert_parsed_expression_is(Infinity::Name(), Infinity(false)); assert_parsed_expression_is(Undefined::Name(), Undefined()); assert_raises_parsing_error("u"); diff --git a/poincare/test/rational.cpp b/poincare/test/rational.cpp index 933cde0fb..2df36c9ee 100644 --- a/poincare/test/rational.cpp +++ b/poincare/test/rational.cpp @@ -93,8 +93,8 @@ QUIZ_CASE(poincare_rational_simplify) { // MaxIntegerString() assert_parsed_expression_simplify_to(MaxIntegerString(), MaxIntegerString()); // OverflowedIntegerString() - assert_parsed_expression_simplify_to(BigOverflowedIntegerString(), "inf"); - assert_parsed_expression_simplify_to(BigOverflowedIntegerString(), "inf"); + assert_parsed_expression_simplify_to(BigOverflowedIntegerString(), Infinity::Name()); + assert_parsed_expression_simplify_to(BigOverflowedIntegerString(), Infinity::Name()); // -OverflowedIntegerString() buffer[0] = '-'; strlcpy(buffer+1, BigOverflowedIntegerString(), 400-1); @@ -143,5 +143,5 @@ QUIZ_CASE(poincare_rational_serialize) { Integer one(1); Integer overflow = Integer::Overflow(false); assert_parsed_expression_serialize_to(Rational(one, overflow), "1/inf"); - assert_parsed_expression_serialize_to(Rational(overflow), "inf"); + assert_parsed_expression_serialize_to(Rational(overflow), Infinity::Name()); }