react-native-executorch 0.10.5 → 0.10.7

package/third-party/common/phonemis/src/phonemis/lang/it/num2word.cpp

@@ -1,268 +1,261 @@
-#include "num2word.h"
 #include "constants.h"
-#include <phonemis/utils/conversions.h>
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
+#include "num2word.h"
+#include "patterns.h"
+#include <phonemis/base/processor/layers/num2word/numerals.h>
+#include <phonemis/base/processor/layers/num2word/patterns.h>
+#include <phonemis/base/processor/layers/num2word/primitives.h>
+#include <phonemis/utils/strings.h>
 
 namespace phonemis::it {
 
-using namespace constants;
-using namespace phonemis::utils;
+using namespace constants::num2word;
+using namespace processor;
+using namespace processor::num2word;
+using namespace utils;
 
 namespace {
-
-// Apocopates a trailing cardinal "uno" to "un" (e.g. "uno" → "un",
-// "ventuno" → "ventun"). Used before singular masculine nouns such as
-// currency units and fraction denominators.
-std::u32string apocopate(std::u32string word) {
-  constexpr std::u32string_view kUno = U"uno";
-  if (word.size() >= kUno.size() &&
-      std::u32string_view(word).substr(word.size() - kUno.size()) == kUno) {
-    size_t pre = word.size() - kUno.size();
-    // Only apocopate when "uno" is a standalone suffix (start of word or
-    // preceded by a boundary), to avoid trimming unrelated words ending in
-    // "uno".
-    if (pre == 0 || word[pre - 1] == U' ' || word[pre - 1] == U'-') {
-      word.replace(pre, kUno.size(), U"un");
-    }
-  }
-  return word;
+uint64_t value(const Number& number) {
+  return value_of(number.integer).value_or(0);
 }
 
-// Composes an ordinal from a cardinal word by stripping its final vowel and
-// appending "esimo". Cardinals ending in "tré" drop the accent but keep the
-// 'e' (e.g. "ventitré" → "ventitreesimo").
-std::u32string cardinal_to_ordinal(std::u32string word) {
-  constexpr std::u32string_view kTre = U"tré";
-  if (word.size() >= kTre.size() &&
-      std::u32string_view(word).substr(word.size() - kTre.size()) == kTre) {
-    word.replace(word.size() - kTre.size(), kTre.size(), U"tre");
-    return word + U"esimo";
-  }
-  if (!word.empty()) {
-    word.pop_back();
-  }
-  return word + U"esimo";
+// The number "1" as written, which counts a singular noun
+bool is_one(const Number& number) {
+  return number.integer == U"1" && number.fraction.empty();
 }
 
-} // namespace
+// ------------------------
+// ----- Number words -----
+// ------------------------
 
-std::u32string Num2Word::to_cardinal_int(int32_t value) const {
-  if (value < 0) {
-    return U"meno " + to_cardinal_int(std::abs(value));
+// ventuno, ventotto: a ten drops its vowel before uno and otto
+std::u32string below_hundred(uint64_t n) {
+  if (n < 20) {
+    return std::u32string(kOnes[n]);
   }
-
-  if (auto it = num2word::kCardinals.find(value); it != num2word::kCardinals.end()) {
-    return it->second;
+  std::u32string tens(kTens[n / 10]);
+  uint64_t unit = n % 10;
+  if (unit == 1 || unit == 8) {
+    tens.pop_back();
   }
+  return tens + (unit ? std::u32string(kOnes[unit]) : U"");
+}
 
-  if (value < 100) {
-    // Italian fuses tens and units into a single word. The tens' final vowel
-    // elides before "uno" (1) and "otto" (8); "tre" takes an accent as a
-    // suffix ("ventitré", "trentatré", ...).
-    int32_t tens = (value / 10) * 10;
-    int32_t units = value % 10;
-    std::u32string tens_word = num2word::kCardinals.at(tens);
-    std::u32string units_word = (units == 3) ? U"tré" : num2word::kCardinals.at(units);
-    if (units == 1 || units == 8) {
-      tens_word.pop_back();
-    }
-    return tens_word + units_word;
+// centotto, novecentottanta: a hundred drops its vowel before otto and ottanta
+std::u32string below_thousand(uint64_t n) {
+  uint64_t h = n / 100, r = n % 100;
+  std::u32string head = h == 0 ? U"" : (h == 1 ? U"cento" : std::u32string(kOnes[h]) + U"cento");
+  if (!head.empty() && (r == 8 || (r >= 80 && r <= 89))) {
+    head.pop_back();
   }
+  return head + (r || head.empty() ? below_hundred(r) : U"");
+}
 
-  // Large-scale decomposition (cento, mille, milione, miliardo) in descending
-  // order.
-  for (auto it = num2word::kLargeCardinals.rbegin(); it != num2word::kLargeCardinals.rend(); ++it) {
-    int64_t base = it->first;
-    if (static_cast<int64_t>(value) < base) continue;
-
-    int32_t high = value / static_cast<int32_t>(base);
-    int32_t low = value % static_cast<int32_t>(base);
-
-    // Base 100/1000 fuse with the multiplier and the remainder into a single
-    // word ("duecento", "duemilaventisei"), dropping "uno" at the multiplier
-    // position ("cento", "mille"). Base 10^6 and above take a space and
-    // require an explicit "un" for a multiplier of 1 ("un milione",
-    // "due milioni").
-    std::u32string head;
-    std::u32string scale;
-    bool space_before_low = false;
-
-    if (base == 100LL) {
-      head = (high == 1) ? U"" : to_cardinal_int(high);
-      scale = U"cento";
-    } else if (base == 1000LL) {
-      head = (high == 1) ? U"" : to_cardinal_int(high);
-      scale = (high == 1) ? U"mille" : U"mila";
-    } else {
-      head = (high == 1) ? U"un " : to_cardinal_int(high) + U" ";
-      scale = (high == 1) ? it->second : num2word::kLargeCardinalsPlural.at(base);
-      space_before_low = true;
+// ventitré, centotré, milletré: a compound ending in tre takes the accent
+std::u32string accented(std::u32string_view words) {
+  std::vector<std::u32string> out;
+  for (auto word : strings::split(words, U' ')) {
+    std::u32string w(word);
+    if (w.size() > 3 && w.ends_with(U"tre")) {
+      w.replace(w.size() - 3, 3, U"tré");
     }
+    out.push_back(w);
+  }
+  return join(out);
+}
 
-    std::u32string res = head + scale;
-    if (low > 0) {
-      res += (space_before_low ? U" " : U"") + to_cardinal_int(low);
+// One word below a million (duemilaventidue), then un milione duecentomila
+std::u32string cardinal(uint64_t n) {
+  std::vector<std::u32string> words;
+  for (auto [scale, one, many] :
+       {std::tuple{1000000000ULL, U"un miliardo", U"miliardi"}, std::tuple{1000000ULL, U"un milione", U"milioni"}}) {
+    if (uint64_t q = n / scale) {
+      words.push_back(q == 1 ? std::u32string(one) : cardinal(q) + U" " + many);
     }
-    return res;
+    n %= scale;
   }
 
-  return conversions::utf8_to_u32(std::to_string(value));
+  uint64_t thousands = n / 1000;
+  n %= 1000;
+  std::u32string head = thousands == 0 ? U"" : (thousands == 1 ? U"mille" : below_thousand(thousands) + U"mila");
+  if (!head.empty() || n || words.empty()) {
+    words.push_back(head + (n || head.empty() ? below_thousand(n) : U""));
+  }
+  return accented(join(words));
 }
 
-std::u32string Num2Word::to_cardinal_float(float value, std::u32string_view repr) const {
-  if (value < 0.0f) {
-    return U"meno " + to_cardinal_float(std::abs(value), repr);
+// primo ... decimo, then the cardinal with -esimo: undicesimo, ventitreesimo, millesimo
+std::u32string ordinal(uint64_t n, char32_t ending) {
+  if (n <= 10) {
+    std::u32string word(kOrdinals[n]);
+    word.back() = ending;
+    return word;
   }
 
-  // The base transform normalizes the decimal separator to '.', but also
-  // accept ',' when this method is invoked directly with a raw representation.
-  std::string value_str = conversions::u32_to_utf8(repr);
-  std::replace(value_str.begin(), value_str.end(), ',', '.');
-
-  // Trim trailing zeros and any dangling decimal point.
-  auto rit = std::find_if(value_str.rbegin(), value_str.rend(),
-                          [](char c) { return c != '0'; });
-  value_str = std::string(value_str.begin(), rit.base());
-  if (!value_str.empty() && value_str.back() == '.') {
-    value_str.pop_back();
+  std::u32string words = cardinal(n);
+  if (words.ends_with(U"tré")) {
+    words.back() = U'e';
+  }
+  if (words.ends_with(U"tre") || words.ends_with(U"sei")) {
+    return words + U"esim" + ending;
   }
+  if (words.ends_with(U"mila")) {
+    return words.substr(0, words.size() - 4) + U"millesim" + ending;
+  }
+  return words.substr(0, words.size() - 1) + U"esim" + ending;
+}
 
-  size_t dot_pos = value_str.find('.');
-  if (dot_pos == std::string::npos) {
-    return to_cardinal_int(value_str.empty() ? 0 : std::stoi(value_str));
+std::u32string digits(std::u32string_view text) {
+  std::vector<std::u32string> words;
+  for (char32_t c : text) {
+    words.emplace_back(kOnes[c - U'0']);
   }
+  return join(words);
+}
+} // namespace
 
-  std::string integer_part_str = value_str.substr(0, dot_pos);
-  std::string fractional_part_str = value_str.substr(dot_pos + 1);
-  int32_t integer_part = integer_part_str.empty() ? 0 : std::stoi(integer_part_str);
-
-  // Leading zeros in the fractional part are spoken as "zero" words; the
-  // remaining digits verbalize as a single cardinal (e.g. 0,05 → "zero virgola
-  // zero cinque", 123,45 → "... virgola quarantacinque").
-  std::u32string frac_words;
-  size_t pos = 0;
-  while (pos < fractional_part_str.size() && fractional_part_str[pos] == '0') {
-    if (!frac_words.empty()) frac_words += U" ";
-    frac_words += U"zero";
-    pos++;
+Num2Word::Num2Word() : Num2WordLayer(kNotation, kJoiners) {
+  add_pattern(std::make_unique<DatePattern>(kDateFormat));
+  for (const auto& format : kPhoneFormats) {
+    add_pattern(std::make_unique<PhonePattern>(format));
   }
-  if (pos < fractional_part_str.size()) {
-    if (!frac_words.empty()) frac_words += U" ";
-    frac_words += to_cardinal_int(std::stoi(fractional_part_str.substr(pos)));
+  add_pattern(std::make_unique<SuffixPattern>(Kind::ORDINAL, kOrdinalSigns, kOrdinalSignFormat));
+  add_pattern(std::make_unique<SuffixPattern>(Kind::ORDINAL, kOrdinalSuffixes));
+  add_pattern(std::make_unique<DecadePattern>());
+}
+
+// ----------------------
+// ----- Resolution -----
+// ----------------------
+
+bool Num2Word::accept(const Match& match, const Context& context) const {
+  switch (match.kind) {
+    case Kind::FRACTION:
+      return kFractions.contains({value(match.numbers[0]), value(match.numbers[1])});
+    case Kind::TIME: {
+      // With a dot, a time comes after "alle" or from 13 on: alle 9.30, 21.30, but versione 2.79
+      uint64_t hours = value(match.numbers[0]);
+      bool decimal = match.separator == U'.' && !kTimeWords.contains(context.before()) && (hours < 13 || hours > 23);
+      return hours <= 24 && value(match.numbers[1]) <= 59 && !decimal;
+    }
+    case Kind::SCALE:
+      // 4K: a resolution
+      return (match.scale != U"k" && match.scale != U"K") || value(match.numbers.back()) >= 10;
+    case Kind::ORDINAL:
+      return value(match.numbers[0]) > 0;
+    default:
+      return true;
   }
+}
 
-  return to_cardinal_int(integer_part) + U" virgola " + frac_words;
+NumberReading Num2Word::resolve(const Match& match, const Context& context) const {
+  return {.month = std::ranges::find(kMonths, strings::to_lower(context.after())) != kMonths.end()};
 }
 
-std::u32string Num2Word::to_ordinal_int(int32_t value, std::u32string_view suffix) const {
-  // The suffix disambiguates gender/number; the default (no suffix, e.g. from
-  // a "1." token) is masculine singular.
-  bool feminine = (suffix == U"ª" || suffix == U"ªs");
-  bool plural   = (suffix == U"ºs" || suffix == U"ªs");
+// --------------------
+// ----- Readings -----
+// --------------------
 
-  auto inflect = [&](std::u32string word) {
-    if (feminine && !word.empty() && word.back() == U'o') {
-      word.back() = U'a';
+std::u32string Num2Word::read_number(const Number& number, const NumberReading& reading) const {
+  if (number.fraction.empty()) {
+    auto n = value_of(number.integer);
+    if (!n || spoken_digits(number, 7)) {
+      return digits(number.integer);
     }
-    if (plural && !word.empty()) {
-      // Italian plural for masculine nouns: -o → -i; for feminine: -a → -e.
-      if (word.back() == U'o')      word.back() = U'i';
-      else if (word.back() == U'a') word.back() = U'e';
-    }
-    return word;
-  };
-
-  if (auto it = num2word::kOrdinals.find(value); it != num2word::kOrdinals.end()) {
-    return inflect(it->second);
+    return *n == 1 && reading.month ? U"primo" : cardinal(*n);
   }
 
-  // Values without a dedicated ordinal entry derive the form from the cardinal
-  // by stripping its final vowel and appending "esimo".
-  return inflect(cardinal_to_ordinal(to_cardinal_int(value)));
+  // The separator is read as written: due virgola cinque, due punto cinque
+  std::vector<std::u32string> fraction;
+  size_t zeros = number.fraction.find_first_not_of(U'0');
+  fraction.insert(fraction.end(), std::min(zeros, number.fraction.size()), U"zero");
+  if (zeros != std::u32string::npos) {
+    fraction.push_back(cardinal(value_of(number.fraction).value_or(0)));
+  }
+  std::u32string head = number.integer.empty() ? U"" : cardinal(value(number)) + U" ";
+  return head + (number.decimal_mark == U',' ? U"virgola " : U"punto ") + join(fraction);
 }
 
-std::u32string Num2Word::to_currency(char32_t currency, std::variant<int32_t, float> number) const {
-  auto it = num2word::kCurrencies.find(currency);
-  if (it == num2word::kCurrencies.end()) {
-    return std::u32string(1, currency);
+std::u32string Num2Word::read_code_digits(std::u32string_view text) const {
+  auto n = value_of(text);
+  if ((text.size() > 1 && text[0] == U'0') || text.size() >= 7 || !n) {
+    return digits(text);
   }
+  return cardinal(*n);
+}
 
-  // Singular only for amounts that round to exactly 1.
-  bool is_singular = std::visit([](auto&& arg) -> bool {
-    using T = std::decay_t<decltype(arg)>;
-    if constexpr (std::is_same_v<T, int32_t>) {
-      return arg == 1;
-    } else {
-      return std::abs(arg - 1.0F) < 1e-6F;
-    }
-  }, number);
-
-  return is_singular ? it->second : num2word::kCurrenciesPlural.at(currency);
+std::u32string Num2Word::read_date(const Match& match, const NumberReading& reading) const {
+  uint64_t day = value(match.numbers[0]);
+  return (day == 1 ? U"primo" : cardinal(day)) + U" " + kMonths[value(match.numbers[1]) - 1] + U" " +
+         cardinal(value(match.numbers[2]));
 }
 
-std::u32string Num2Word::to_fraction(int32_t numerator, int32_t denominator) const {
-  // Numerator apocopates "uno" because it precedes a masculine noun
-  // ("un mezzo", "un terzo", "un quarto", "un decimo").
-  std::u32string num_word = apocopate(to_cardinal_int(numerator));
-  bool plural = std::abs(numerator) > 1;
-
-  auto with_plural = [&](std::u32string_view base) -> std::u32string {
-    std::u32string w(base);
-    if (plural && !w.empty() && w.back() == U'o') w.back() = U'i';
-    return num_word + U" " + w;
-  };
-
-  // Dedicated nouns for denominators 2/3/4; other denominators fall back to
-  // the ordinal form, agreeing in number.
-  if (denominator == 2) return with_plural(U"mezzo");
-  if (denominator == 3) return with_plural(U"terzo");
-  if (denominator == 4) return with_plural(U"quarto");
-
-  std::u32string ord = to_ordinal_int(denominator);
-  if (plural && !ord.empty() && ord.back() == U'o') ord.back() = U'i';
-  return num_word + U" " + ord;
+std::u32string Num2Word::read_phone(const Match& match, const NumberReading& reading) const {
+  // Digit by digit: tre tre tre, uno due tre ...
+  std::vector<std::u32string> groups;
+  for (const auto& group : match.numbers) {
+    groups.push_back(digits(group.integer));
+  }
+  return join(groups);
 }
 
-std::u32string Num2Word::to_day(uint32_t day) const {
-  return to_cardinal_int(static_cast<int32_t>(day));
+std::u32string Num2Word::read_fraction(const Match& match, const NumberReading& reading) const {
+  return kFractions.at({value(match.numbers[0]), value(match.numbers[1])});
 }
 
-std::u32string Num2Word::to_month(uint32_t month) const {
-  if (month >= 1 && month <= 12) {
-    return num2word::kMonths[month];
-  }
-  return U"";
+std::u32string Num2Word::read_time(const Match& match, const NumberReading& reading) const {
+  // alle 21.30: ventuno e trenta
+  uint64_t hours = value(match.numbers[0]), minutes = value(match.numbers[1]);
+  std::u32string hour = hours == 1 ? U"una" : cardinal(hours);
+  return minutes ? hour + U" e " + cardinal(minutes) : hour;
 }
 
-std::u32string Num2Word::to_year(uint32_t year) const {
-  // Italian reads years as plain cardinals (e.g. 2026 → "duemilaventisei").
-  return to_cardinal_int(static_cast<int32_t>(year));
+std::u32string Num2Word::read_ordinal(const Match& match, const NumberReading& reading) const {
+  char32_t ending = match.suffix == U"ª" ? U'a' : (match.suffix == U"º" ? U'o' : match.suffix.back());
+  return ordinal(value(match.numbers[0]), ending);
 }
 
-bool Num2Word::is_ordinal_suffix(std::u32string_view suffix) const {
-  return num2word::kOrdinalSuffixes.contains(std::u32string(suffix));
+std::u32string Num2Word::read_decade(const Match& match, const NumberReading& reading) const {
+  return cardinal(value(match.numbers[0])); // gli anni '80: gli anni ottanta
 }
 
-std::u32string Num2Word::verbalize(const processor::num2word::StringifiedNumber& number) const {
-  using Mode = processor::num2word::Mode;
+std::u32string Num2Word::read_money(const Number& number, const Match& match, const NumberReading& reading) const {
+  const Forms& currency = kCurrencies.at(std::u32string(match.unit));
 
-  std::u32string result = Num2WordLayer::verbalize(number);
+  // 3 mln €: tre milioni di euro, but 10 mila €: diecimila euro
+  if (!match.scale.empty()) {
+    bool thousands = kScales.at(std::u32string(match.scale)).one == U"mila";
+    return read_scale(number, match, reading) + (thousands ? U" " : U" di ") + currency.many;
+  }
 
-  // The base produces "<cardinal> <currency>"; apocopate the cardinal half so
-  // amounts of 1 (or ending in "uno") read as "un <noun>" instead of "uno
-  // <noun>".
-  if (number.conversionMode == Mode::CURRENCY) {
-    size_t last_space = result.rfind(U' ');
-    if (last_space != std::u32string::npos) {
-      std::u32string head = result.substr(0, last_space);
-      std::u32string tail = result.substr(last_space);
-      result = apocopate(std::move(head)) + tail;
-    }
+  // 10,50 €: dieci euro e cinquanta
+  if (number.fraction.size() == 2 && number.decimal_mark == U',') {
+    Number whole{.integer = number.integer.empty() ? U"0" : number.integer, .grouped = number.grouped};
+    uint64_t cents = value_of(number.fraction).value_or(0);
+    return read_number(whole, reading) + U" " + (number.integer == U"1" ? currency.one : currency.many) +
+           (cents ? U" e " + cardinal(cents) : U"");
+  }
+  return read_number(number, reading) + U" " + (is_one(number) ? currency.one : currency.many);
+}
+
+std::u32string Num2Word::read_scale(const Number& number, const Match& match, const NumberReading& reading) const {
+  const Forms& scale = kScales.at(std::u32string(match.scale));
+
+  // 74 mila: settantaquattromila
+  if (scale.one == U"mila" && number.fraction.empty()) {
+    return cardinal(value(number) * 1000);
   }
+  bool singular = value(number) < 2 && number.fraction.empty();
+  return read_number(number, reading) + U" " + (singular ? scale.one : scale.many);
+}
+
+std::u32string Num2Word::read_percent(const Number& number, const Match& match, const NumberReading& reading) const {
+  std::u32string suffix = match.suffix.empty() ? U"" : U" " + std::u32string(match.suffix);
+  return read_number(number, reading) + U" per cento" + suffix;
+}
 
-  return result;
+std::u32string Num2Word::read_unit(const Number& number, const Match& match, const NumberReading& reading) const {
+  const Forms& unit = kUnits.at(std::u32string(match.unit));
+  return read_number(number, reading) + U" " + (is_one(number) ? unit.one : unit.many);
 }
 
 } // namespace phonemis::it

package/third-party/common/phonemis/src/phonemis/lang/it/num2word.h

@@ -1,30 +1,42 @@
 #pragma once
 
-#include <phonemis/base/processor/num2word/layer.h>
+#include <phonemis/base/processor/layers/num2word/layer.h>
+
 #include <string>
-#include <variant>
 
 namespace phonemis::it {
 
-class Num2Word : public processor::num2word::Num2WordLayer {
+// How an Italian number is read, from the words around it.
+struct NumberReading {
+  bool month = false; // 1 maggio: "1" before a month is "primo"
+};
+
+class Num2Word : public processor::num2word::Num2WordLayer<NumberReading> {
 public:
-    using Num2WordLayer::Num2WordLayer;
-
-    char32_t decimal_separator() const override { return U','; }
-    std::u32string to_cardinal_int(int32_t number) const override;
-    std::u32string to_cardinal_float(float number, std::u32string_view repr) const override;
-    std::u32string to_ordinal_int(int32_t number, std::u32string_view suffix = U"") const override;
-    std::u32string to_currency(char32_t currency, std::variant<int32_t, float> number) const override;
-    std::u32string to_fraction(int32_t numerator, int32_t denominator) const override;
-    std::u32string to_day(uint32_t day) const override;
-    std::u32string to_month(uint32_t month) const override;
-    std::u32string to_year(uint32_t year) const override;
-    bool is_ordinal_suffix(std::u32string_view suffix) const override;
+  Num2Word();
 
 protected:
-    // Overridden so we can apocopate the final "uno" before a currency noun
-    // ("uno dollaro" → "un dollaro", "uno euro" → "un euro").
-    std::u32string verbalize(const processor::num2word::StringifiedNumber& number) const override;
+  using Context = processor::Context;
+  using Match = processor::num2word::Match;
+  using Number = processor::num2word::Number;
+
+  // Resolution
+  bool accept(const Match& match, const Context& context) const override;
+  NumberReading resolve(const Match& match, const Context& context) const override;
+
+  // Readings
+  std::u32string read_number(const Number& number, const NumberReading& reading) const override;
+  std::u32string read_code_digits(std::u32string_view digits) const override;
+  std::u32string read_date(const Match& match, const NumberReading& reading) const override;
+  std::u32string read_phone(const Match& match, const NumberReading& reading) const override;
+  std::u32string read_fraction(const Match& match, const NumberReading& reading) const override;
+  std::u32string read_time(const Match& match, const NumberReading& reading) const override;
+  std::u32string read_ordinal(const Match& match, const NumberReading& reading) const override;
+  std::u32string read_decade(const Match& match, const NumberReading& reading) const override;
+  std::u32string read_money(const Number& number, const Match& match, const NumberReading& reading) const override;
+  std::u32string read_scale(const Number& number, const Match& match, const NumberReading& reading) const override;
+  std::u32string read_percent(const Number& number, const Match& match, const NumberReading& reading) const override;
+  std::u32string read_unit(const Number& number, const Match& match, const NumberReading& reading) const override;
 };
 
 } // namespace phonemis::it

package/third-party/common/phonemis/src/phonemis/lang/it/patterns.cpp

@@ -0,0 +1,25 @@
+#include "patterns.h"
+#include <phonemis/base/processor/layers/num2word/primitives.h>
+
+#include <optional>
+
+namespace phonemis::it {
+
+using namespace processor;
+using namespace processor::num2word;
+
+std::optional<Match> DecadePattern::match(std::u32string_view text, size_t position) const {
+  if (!is_clear_before(text, position) || text[position] != U'\'') {
+    return std::nullopt;
+  }
+
+  // Two digits: a ten other than 00
+  Number decade = digits_at(text, position + 1);
+  if (decade.integer.size() != 2 || decade.integer[0] == U'0' || decade.integer[1] != U'0' ||
+      !is_clear_after(text, decade.span.end)) {
+    return std::nullopt;
+  }
+  return Match{.kind = Kind::DECADE, .span = {position, decade.span.end}, .numbers = {decade}};
+}
+
+} // namespace phonemis::it

package/third-party/common/phonemis/src/phonemis/lang/it/patterns.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <phonemis/base/processor/layers/num2word/pattern.h>
+
+namespace phonemis::it {
+
+// '80: a decade written as its two digits after an apostrophe (gli anni '80).
+class DecadePattern : public processor::num2word::Pattern {
+public:
+  DecadePattern() : Pattern(processor::num2word::Kind::DECADE) {}
+
+  std::optional<processor::num2word::Match> match(std::u32string_view text, size_t position) const override;
+};
+
+} // namespace phonemis::it

package/third-party/common/phonemis/src/phonemis/lang/it/pipeline.h

@@ -7,8 +7,8 @@
 #include <phonemis/base/ipipeline.h>
 #include <phonemis/base/phonemizer/hybrid_phonemizer.h>
 #include <phonemis/base/phonemizer/lexicon_phonemizer.h>
+#include <phonemis/base/processor/preprocessor.h>
 #include <phonemis/base/processor/processor.h>
-#include <phonemis/base/processor/trim_layer.h>
 #include <phonemis/base/tokenizer/tokenizer.h>
 #include <phonemis/utils/conversions.h>
 
@@ -24,8 +24,8 @@ public:
         phonemizer_(config.phonemizer) {
 
     // 1. Setup Preprocessing layers
-    preprocessor_.add_layer(std::make_unique<processor::TrimLayer>());
-    preprocessor_.add_layer(std::make_unique<Num2Word>());
+    preprocessor_ = processor::make_preprocessor<Num2Word>(
+        config.preprocessor, {.terms = &constants::term2word::kTerms, .symbols = &constants::sym2word::kSymbols});
   }
 
   // Performs a preprocessing stage of the pipeline.