[poincare] Fix power serialization

apps/solver/test/equation_store.cpp

@@ -120,7 +120,7 @@ QUIZ_CASE(equation_solve) {
 
   // x^2+x+1=3*x^2+pi*x-R(5)
   const char * equations11[] = {"x^2+x+1=3*x^2+P*x-R(5)", 0};
-  const char * solutions11[] = {"(1-P+R(9+8*R(5)-2*P+P$2$))/(4)", "(1-P-R(9+8*R(5)-2*P+P$2$))/(4)", "9+8*R(5)-2*P+P$2$"};
+  const char * solutions11[] = {"(1-P+R(9+8*R(5)-2*P+P$2#))/(4)", "(1-P-R(9+8*R(5)-2*P+P$2#))/(4)", "9+8*R(5)-2*P+P$2#"};
   assert_equation_system_exact_solve_to(equations11, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions11, 2);
 
   // TODO

ion/include/ion/charset.h

@@ -28,7 +28,8 @@ enum Charset : char {
   AlmostEqual = (char)150,
   Degree = (char)151,
   Empty = (char)152, // This char is used to be parsed into EmptyExpression
-  Superscript = (char)153 // This char is used to parse Power
+  LeftSuperscript = (char)153, // This char is used to parse Power
+  RightSuperscript = (char)154 // This char is used to parse Power
 };
 
 }

poincare/src/parsing/parser.cpp

@@ -54,11 +54,11 @@ Expression Parser::parseUntil(Token::Type stoppingType) {
     &Parser::parseUnexpected,      // Token::EndOfStream
     &Parser::parseStore,           // Token::Store
     &Parser::parseEqual,           // Token::Equal
+    &Parser::parseUnexpected,      // Token::RightSuperscript
     &Parser::parseUnexpected,      // Token::RightBracket
     &Parser::parseUnexpected,      // Token::RightParenthesis
     &Parser::parseUnexpected,      // Token::RightBrace
     &Parser::parseUnexpected,      // Token::Comma
-    &Parser::parseSuperscript,     // Token::Superscript
     &Parser::parsePlus,            // Token::Plus
     &Parser::parseMinus,           // Token::Minus
     &Parser::parseTimes,           // Token::Times
@@ -66,6 +66,7 @@ Expression Parser::parseUntil(Token::Type stoppingType) {
     &Parser::parseImplicitTimes,   // Token::ImplicitTimes
     &Parser::parseCaret,           // Token::Power
     &Parser::parseBang,            // Token::Bang
+    &Parser::parseLeftSuperscript, // Token::LeftSuperscript
     &Parser::parseMatrix,          // Token::LeftBracket
     &Parser::parseLeftParenthesis, // Token::LeftParenthesis
     &Parser::parseUnexpected,      // Token::LeftBrace
@@ -251,16 +252,16 @@ void Parser::parseStore(Expression & leftHandSide) {
   leftHandSide = Store(leftHandSide, static_cast<SymbolAbstract&>(rightHandSide));
 }
 
-void Parser::parseSuperscript(Expression & leftHandSide) {
+void Parser::parseLeftSuperscript(Expression & leftHandSide) {
   if (leftHandSide.isUninitialized()) {
     m_status = Status::Error; // Power must have a left operand
     return;
   }
-  Expression rightHandSide = parseUntil(Token::Superscript);
+  Expression rightHandSide = parseUntil(Token::RightSuperscript);
   if (m_status != Status::Progress) {
     return;
   }
-  if (!popTokenIfType(Token::Superscript)) {
+  if (!popTokenIfType(Token::RightSuperscript)) {
     m_status = Status::Error; // Right superscript marker missing.
     return;
   }

poincare/src/parsing/parser.h

@@ -61,7 +61,7 @@ private:
   void parseCaret(Expression & leftHandSide);
   void parseEqual(Expression & leftHandSide);
   void parseStore(Expression & leftHandSide);
-  void parseSuperscript(Expression & leftHandSide);
+  void parseLeftSuperscript(Expression & leftHandSide);
 
   // Parsing helpers
   bool parseBinaryOperator(const Expression & leftHandSide, Expression & rightHandSide, Token::Type stoppingType);

poincare/src/parsing/token.h

@@ -24,13 +24,13 @@ public:
        * token of lesser precedence than Equal, and this prevents expressions
        * such as "3=4>a". Tokenizer::parseStore uses a special algorithm that
        * prevents (3>4=a). */
+    RightSuperscript,
+      /* Superscript marks the limit of a power. For instance:
+       * 2 LeftSuperscript 3! RightSuperscript ! is (2^(3!))! */
     RightBracket,
     RightParenthesis,
     RightBrace,
     Comma,
-    Superscript,
-      /* Superscript marks the limit of a power. For instance:
-       * 2 Superscript 3! Superscript ! is (2^(3!))! */
     Plus,
     Minus,
     Times,
@@ -42,6 +42,7 @@ public:
        * in order to allow the Parser to insert such Tokens where needed. */
     Caret,
     Bang,
+    LeftSuperscript,
     LeftBracket,
     LeftParenthesis,
     LeftBrace,

poincare/src/parsing/tokenizer.cpp

@@ -125,8 +125,11 @@ Token Tokenizer::popToken() {
   if (currentChar == '^') {
     return Token(Token::Caret);
   }
-  if (currentChar == Ion::Charset::Superscript) {
-    return Token(Token::Superscript);
+  if (currentChar == Ion::Charset::LeftSuperscript) {
+    return Token(Token::LeftSuperscript);
+  }
+  if (currentChar == Ion::Charset::RightSuperscript) {
+    return Token(Token::RightSuperscript);
   }
   if (currentChar == '!') {
     return Token(Token::Bang);

poincare/src/vertical_offset_layout.cpp

@@ -174,12 +174,13 @@ int VerticalOffsetLayoutNode::serialize(char * buffer, int bufferSize, Preferenc
     return numberOfChar;
   }
   assert(m_type == Type::Superscript);
-  // If the layout is a superscript, write "Ion::Charset::Superscript indice Ion::Charset::Superscript"
-  int numberOfChar = SerializationHelper::Char(buffer, bufferSize, Ion::Charset::Superscript);
+  /* If the layout is a superscript, write:
+   * "Ion::Charset::LeftSuperscript indice Ion::Charset::RightSuperscript" */
+  int numberOfChar = SerializationHelper::Char(buffer, bufferSize, Ion::Charset::LeftSuperscript);
   if (numberOfChar >= bufferSize-1) { return bufferSize-1; }
   numberOfChar += const_cast<VerticalOffsetLayoutNode *>(this)->indiceLayout()->serialize(buffer+numberOfChar, bufferSize-numberOfChar, floatDisplayMode, numberOfSignificantDigits);
   if (numberOfChar >= bufferSize-1) { return bufferSize-1; }
-  numberOfChar += SerializationHelper::Char(buffer+numberOfChar, bufferSize-numberOfChar, Ion::Charset::Superscript);
+  numberOfChar += SerializationHelper::Char(buffer+numberOfChar, bufferSize-numberOfChar, Ion::Charset::RightSuperscript);
   if (numberOfChar >= bufferSize-1) { return bufferSize-1; }
 
   buffer[numberOfChar] = 0;

poincare/test/helper.cpp

@@ -39,7 +39,8 @@ void translate_in_special_chars(char * expression) {
       case '*': *c = Ion::Charset::MultiplicationSign; break;
       case '>': *c = Ion::Charset::Sto; break;
       case '?': *c = Poincare::Symbol::SpecialSymbols::UnknownX; break;
-      case '$': *c = Ion::Charset::Superscript; break;
+      case '$': *c = Ion::Charset::LeftSuperscript; break;
+      case '#': *c = Ion::Charset::RightSuperscript; break;
     }
   }
 }
@@ -56,7 +57,8 @@ void translate_in_ASCII_chars(char * expression) {
       case Ion::Charset::MiddleDot: *c = '*'; break;
       case Ion::Charset::Sto: *c = '>'; break;
       case Poincare::Symbol::SpecialSymbols::UnknownX: *c = '?'; break;
-      case Ion::Charset::Superscript: *c = '$'; break;
+      case Ion::Charset::LeftSuperscript: *c = '$'; break;
+      case Ion::Charset::RightSuperscript: *c = '#'; break;
     }
   }
 }