dom/xslt/xslt/txXSLTNumberCounters.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "txXSLTNumber.h"
   7 #include "nsReadableUtils.h"
   8 #include "txCore.h"
   9
  10 class txDecimalCounter : public txFormattedCounter {
  11  public:
  12   txDecimalCounter() : mMinLength(1), mGroupSize(50) {}
  13
  14   txDecimalCounter(int32_t aMinLength, int32_t aGroupSize,
  15                    const nsAString& mGroupSeparator);
  16
  17   virtual void appendNumber(int32_t aNumber, nsAString& aDest) override;
  18
  19  private:
  20   int32_t mMinLength;
  21   int32_t mGroupSize;
  22   nsString mGroupSeparator;
  23 };
  24
  25 class txAlphaCounter : public txFormattedCounter {
  26  public:
  27   explicit txAlphaCounter(char16_t aOffset) : mOffset(aOffset) {}
  28
  29   virtual void appendNumber(int32_t aNumber, nsAString& aDest) override;
  30
  31  private:
  32   char16_t mOffset;
  33 };
  34
  35 class txRomanCounter : public txFormattedCounter {
  36  public:
  37   explicit txRomanCounter(bool aUpper) : mTableOffset(aUpper ? 30 : 0) {}
  38
  39   void appendNumber(int32_t aNumber, nsAString& aDest) override;
  40
  41  private:
  42   int32_t mTableOffset;
  43 };
  44
  45 nsresult txFormattedCounter::getCounterFor(const nsString& aToken,
  46                                            int32_t aGroupSize,
  47                                            const nsAString& aGroupSeparator,
  48                                            txFormattedCounter*& aCounter) {
  49   int32_t length = aToken.Length();
  50   NS_ASSERTION(length, "getting counter for empty token");
  51   aCounter = 0;
  52
  53   if (length == 1) {
  54     char16_t ch = aToken.CharAt(0);
  55     switch (ch) {
  56       case 'i':
  57       case 'I':
  58         aCounter = new txRomanCounter(ch == 'I');
  59         break;
  60
  61       case 'a':
  62       case 'A':
  63         aCounter = new txAlphaCounter(ch);
  64         break;
  65
  66       case '1':
  67       default:
  68         // if we don't recognize the token then use "1"
  69         aCounter = new txDecimalCounter(1, aGroupSize, aGroupSeparator);
  70         break;
  71     }
  72     MOZ_ASSERT(aCounter);
  73     return NS_OK;
  74   }
  75
  76   // for now, the only multi-char token we support are decimals
  77   int32_t i;
  78   for (i = 0; i < length - 1; ++i) {
  79     if (aToken.CharAt(i) != '0') break;
  80   }
  81   if (i == length - 1 && aToken.CharAt(i) == '1') {
  82     aCounter = new txDecimalCounter(length, aGroupSize, aGroupSeparator);
  83   } else {
  84     // if we don't recognize the token then use '1'
  85     aCounter = new txDecimalCounter(1, aGroupSize, aGroupSeparator);
  86   }
  87   MOZ_ASSERT(aCounter);
  88   return NS_OK;
  89 }
  90
  91 txDecimalCounter::txDecimalCounter(int32_t aMinLength, int32_t aGroupSize,
  92                                    const nsAString& aGroupSeparator)
  93     : mMinLength(aMinLength),
  94       mGroupSize(aGroupSize),
  95       mGroupSeparator(aGroupSeparator) {
  96   if (mGroupSize <= 0) {
  97     mGroupSize = aMinLength + 10;
  98   }
  99 }
 100
 101 void txDecimalCounter::appendNumber(int32_t aNumber, nsAString& aDest) {
 102   const int32_t bufsize = 10;  // must be able to fit an int32_t
 103   char16_t buf[bufsize];
 104   int32_t pos = bufsize;
 105   while (aNumber > 0) {
 106     int32_t ch = aNumber % 10;
 107     aNumber /= 10;
 108     buf[--pos] = ch + '0';
 109   }
 110
 111   // in case we didn't get a long enough string
 112   int32_t end = (bufsize > mMinLength) ? bufsize - mMinLength : 0;
 113   while (pos > end) {
 114     buf[--pos] = '0';
 115   }
 116
 117   // in case we *still* didn't get a long enough string.
 118   // this should be very rare since it only happens if mMinLength is bigger
 119   // then the length of any int32_t.
 120   // pos will always be zero
 121   int32_t extraPos = mMinLength;
 122   while (extraPos > bufsize) {
 123     aDest.Append(char16_t('0'));
 124     --extraPos;
 125     if (extraPos % mGroupSize == 0) {
 126       aDest.Append(mGroupSeparator);
 127     }
 128   }
 129
 130   // copy string to buffer
 131   if (mGroupSize >= bufsize - pos) {
 132     // no grouping will occur
 133     aDest.Append(buf + pos, (uint32_t)(bufsize - pos));
 134   } else {
 135     // append chars up to first grouping separator
 136     int32_t len = ((bufsize - pos - 1) % mGroupSize) + 1;
 137     aDest.Append(buf + pos, len);
 138     pos += len;
 139     while (bufsize - pos > 0) {
 140       aDest.Append(mGroupSeparator);
 141       aDest.Append(buf + pos, mGroupSize);
 142       pos += mGroupSize;
 143     }
 144     NS_ASSERTION(bufsize == pos, "error while grouping");
 145   }
 146 }
 147
 148 void txAlphaCounter::appendNumber(int32_t aNumber, nsAString& aDest) {
 149   char16_t buf[12];
 150   buf[11] = 0;
 151   int32_t pos = 11;
 152   while (aNumber > 0) {
 153     --aNumber;
 154     int32_t ch = aNumber % 26;
 155     aNumber /= 26;
 156     buf[--pos] = ch + mOffset;
 157   }
 158
 159   aDest.Append(buf + pos, (uint32_t)(11 - pos));
 160 }
 161
 162 const char* const kTxRomanNumbers[] = {
 163     "", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm",
 164     "", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc",
 165     "", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix",
 166     "", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM",
 167     "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC",
 168     "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
 169
 170 void txRomanCounter::appendNumber(int32_t aNumber, nsAString& aDest) {
 171   // Numbers bigger then 3999 and negative numbers can't be done in roman
 172   if (uint32_t(aNumber) >= 4000) {
 173     txDecimalCounter().appendNumber(aNumber, aDest);
 174     return;
 175   }
 176
 177   while (aNumber >= 1000) {
 178     aDest.Append(!mTableOffset ? char16_t('m') : char16_t('M'));
 179     aNumber -= 1000;
 180   }
 181
 182   int32_t posValue;
 183
 184   // Hundreds
 185   posValue = aNumber / 100;
 186   aNumber %= 100;
 187   AppendASCIItoUTF16(
 188       mozilla::MakeStringSpan(kTxRomanNumbers[posValue + mTableOffset]), aDest);
 189   // Tens
 190   posValue = aNumber / 10;
 191   aNumber %= 10;
 192   AppendASCIItoUTF16(
 193       mozilla::MakeStringSpan(kTxRomanNumbers[10 + posValue + mTableOffset]),
 194       aDest);
 195   // Ones
 196   AppendASCIItoUTF16(
 197       mozilla::MakeStringSpan(kTxRomanNumbers[20 + aNumber + mTableOffset]),
 198       aDest);
 199 }