tor-browser

messageformat2_serializer.cpp (7897B)

---

// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

#include "unicode/utypes.h"

#if !UCONFIG_NO_NORMALIZATION

#if !UCONFIG_NO_FORMATTING

#if !UCONFIG_NO_MF2

#include "unicode/messageformat2_data_model.h"
#include "messageformat2_macros.h"
#include "messageformat2_serializer.h"
#include "uvector.h" // U_ASSERT

U_NAMESPACE_BEGIN

namespace message2 {

// Generates a string representation of a data model
// ------------------------------------------------

using namespace data_model;

// Private helper methods

void Serializer::whitespace() {
   result += SPACE;
}

void Serializer::emit(UChar32 c) {
   result += c;
}

void Serializer::emit(const UnicodeString& s) {
   result += s;
}

void Serializer::emit(const std::u16string_view& token) {
   result.append(token);
}

void Serializer::emit(const Literal& l) {
   if (l.isQuoted()) {
     emit(PIPE);
   }
   const UnicodeString& contents = l.unquoted();
   for (int32_t i = 0; ((int32_t) i) < contents.length(); i++) {
       // Re-escape any escaped-char characters
       switch(contents[i]) {
       case BACKSLASH:
       case PIPE:
       case LEFT_CURLY_BRACE:
       case RIGHT_CURLY_BRACE: {
           emit(BACKSLASH);
           break;
       }
       default: {
           break;
       }
       }
       emit(contents[i]);
   }
   if (l.isQuoted()) {
       emit(PIPE);
   }
}

void Serializer::emit(const Key& k) {
   if (k.isWildcard()) {
       emit(ASTERISK);
       return;
   }
   emit(k.asLiteral());
}

void Serializer::emit(const SelectorKeys& k) {
 const Key* ks = k.getKeysInternal();
 int32_t len = k.len;
 // It would be an error for `keys` to be empty;
 // that would mean this is the single `pattern`
 // variant, and in that case, this method shouldn't be called
 U_ASSERT(len > 0);
 for (int32_t i = 0; i < len; i++) {
   if (i != 0) {
     whitespace();
   }
   emit(ks[i]);
 }
}

void Serializer::emit(const Operand& rand) {
   U_ASSERT(!rand.isNull());

   if (rand.isVariable()) {
       emit(DOLLAR);
       emit(rand.asVariable());
   } else {
       // Literal: quoted or unquoted
       emit(rand.asLiteral());
   }
}

void Serializer::emit(const OptionMap& options) {
   // Errors should have been checked before this point
   UErrorCode localStatus = U_ZERO_ERROR;
   U_ASSERT(!options.bogus);
   for (int32_t i = 0; i < options.size(); i++) {
       const Option& opt = options.getOption(i, localStatus);
       // No need to check error code, since we already checked
       // that !bogus
       whitespace();
       emit(opt.getName());
       emit(EQUALS);
       emit(opt.getValue());
   }
}

void Serializer::emitAttributes(const OptionMap& attributes) {
   // Errors should have been checked before this point
   UErrorCode localStatus = U_ZERO_ERROR;
   U_ASSERT(!attributes.bogus);
   for (int32_t i = 0; i < attributes.size(); i++) {
       const Option& attr = attributes.getOption(i, localStatus);
       // No need to check error code, since we already checked
       // that !bogus
       whitespace();
       emit(AT);
       emit(attr.getName());
       const Operand& v = attr.getValue();
       if (!v.isNull()) {
           emit(EQUALS);
           emit(v);
       }
   }
}

void Serializer::emit(const Expression& expr) {
   emit(LEFT_CURLY_BRACE);

   if (!expr.isFunctionCall()) {
       // Literal or variable, no annotation
       emit(expr.getOperand());
   } else {
       // Function call or reserved
       if (!expr.isStandaloneAnnotation()) {
         // Must be a function call that has an operand
         emit(expr.getOperand());
         whitespace();
       }
       UErrorCode localStatus = U_ZERO_ERROR;
       const Operator* rator = expr.getOperator(localStatus);
       U_ASSERT(U_SUCCESS(localStatus));
       emit(COLON);
       emit(rator->getFunctionName());
       // No whitespace after function name, in case it has
       // no options. (when there are options, emit(OptionMap) will
       // emit the leading whitespace)
       emit(rator->getOptionsInternal());
   }
   emitAttributes(expr.getAttributesInternal());
   emit(RIGHT_CURLY_BRACE);
}

void Serializer::emit(const PatternPart& part) {
   if (part.isText()) {
       // Raw text
       const UnicodeString& text = part.asText();
       // Re-escape '{'/'}'/'\''|'
       for (int32_t i = 0; ((int32_t) i) < text.length(); i++) {
         switch(text[i]) {
         case PIPE:
         case BACKSLASH:
         case LEFT_CURLY_BRACE:
         case RIGHT_CURLY_BRACE: {
           emit(BACKSLASH);
           break;
         }
         default:
           break;
         }
         emit(text[i]);
       }
       return;
   }
   // Markup
   if (part.isMarkup()) {
       const Markup& markup = part.asMarkup();
       emit(LEFT_CURLY_BRACE);
       if (markup.isClose()) {
           emit(SLASH);
           } else {
           emit(NUMBER_SIGN);
       }
       emit(markup.getName());
       emit(markup.getOptionsInternal());
       emitAttributes(markup.getAttributesInternal());
       if (markup.isStandalone()) {
           emit(SLASH);
       }
       emit(RIGHT_CURLY_BRACE);
       return;
   }
   // Expression
   emit(part.contents());
}

void Serializer::emit(const Pattern& pat) {
   int32_t len = pat.numParts();
   // Always quote pattern, which should match the normalized input
   // if the parser is constructing it correctly
   emit(LEFT_CURLY_BRACE);
   emit(LEFT_CURLY_BRACE);
   for (int32_t i = 0; i < len; i++) {
       // No whitespace is needed here -- see the `pattern` nonterminal in the grammar
       emit(pat.getPart(i));
   }
   emit(RIGHT_CURLY_BRACE);
   emit(RIGHT_CURLY_BRACE);
}

void Serializer::serializeDeclarations() {
   const Binding* bindings = dataModel.getLocalVariablesInternal();
   U_ASSERT(dataModel.bindingsLen == 0 || bindings != nullptr);

   for (int32_t i = 0; i < dataModel.bindingsLen; i++) {
       const Binding& b = bindings[i];
       if (b.isLocal()) {
           // No whitespace needed here -- see `message` in the grammar
           emit(ID_LOCAL);
           whitespace();
           emit(DOLLAR);
           emit(b.getVariable());
           // No whitespace needed here -- see `local-declaration` in the grammar
           emit(EQUALS);
           // No whitespace needed here -- see `local-declaration` in the grammar
       } else {
           // Input declaration
           emit(ID_INPUT);
           // No whitespace needed here -- see `input-declaration` in the grammar
       }
       emit(b.getValue());
   }
}

void Serializer::serializeSelectors() {
   U_ASSERT(!dataModel.hasPattern());
   const VariableName* selectors = dataModel.getSelectorsInternal();

   emit(ID_MATCH);
   for (int32_t i = 0; i < dataModel.numSelectors(); i++) {
       whitespace();
       emit(DOLLAR);
       emit(selectors[i]);
   }
}

void Serializer::serializeVariants() {
   U_ASSERT(!dataModel.hasPattern());
   const Variant* variants = dataModel.getVariantsInternal();
   whitespace();
   for (int32_t i = 0; i < dataModel.numVariants(); i++) {
       const Variant& v = variants[i];
       emit(v.getKeys());
       // No whitespace needed here -- see `variant` in the grammar
       emit(v.getPattern());
   }
}


// Main (public) serializer method
void Serializer::serialize() {
   serializeDeclarations();
   // Pattern message
   if (dataModel.hasPattern()) {
     emit(dataModel.getPattern());
   } else {
     // Selectors message
     serializeSelectors();
     serializeVariants();
   }
}

} // namespace message2
U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_MF2 */

#endif /* #if !UCONFIG_NO_FORMATTING */

#endif /* #if !UCONFIG_NO_NORMALIZATION */