PageRenderTime 64ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/libreoffice-3.6.0.2/binfilter/bf_svtools/source/numbers/svt_zforscan.cxx

#
C++ | 2768 lines | 2547 code | 84 blank | 137 comment | 617 complexity | 20ad6b6e255dee4815d937b829cdec26 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, AGPL-1.0, BSD-3-Clause-No-Nuclear-License-2014, GPL-3.0, LGPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    2. 

  2. /*************************************************************************
    3. 

  3.  *
    4. 

  4.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    5. 

  5.  *
    6. 

  6.  * Copyright 2000, 2010 Oracle and/or its affiliates.
    7. 

  7.  *
    8. 

  8.  * OpenOffice.org - a multi-platform office productivity suite
    9. 

  9.  *
    10. 

  10.  * This file is part of OpenOffice.org.
    11. 

  11.  *
    12. 

  12.  * OpenOffice.org is free software: you can redistribute it and/or modify
    13. 

  13.  * it under the terms of the GNU Lesser General Public License version 3
    14. 

  14.  * only, as published by the Free Software Foundation.
    15. 

  15.  *
    16. 

  16.  * OpenOffice.org is distributed in the hope that it will be useful,
    17. 

  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    18. 

  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    19. 

  19.  * GNU Lesser General Public License version 3 for more details
    20. 

  20.  * (a copy is included in the LICENSE file that accompanied this code).
    21. 

  21.  *
    22. 

  22.  * You should have received a copy of the GNU Lesser General Public License
    23. 

  23.  * version 3 along with OpenOffice.org.  If not, see
    24. 

  24.  * <http://www.openoffice.org/license.html>
    25. 

  25.  * for a copy of the LGPLv3 License.
    26. 

  26.  *
    27. 

  27.  ************************************************************************/
    28. 

  28. 

  29. #include <stdlib.h>
    30. 

  30. 

  31. #include <tools/debug.hxx>
    32. 

  32. #include <i18npool/mslangid.hxx>
    33. 

  33. #include <unotools/charclass.hxx>
    34. 

  34. #include <unotools/localedatawrapper.hxx>
    35. 

  35. #include <unotools/numberformatcodewrapper.hxx>
    36. 

  36. #include <rtl/instance.hxx>
    37. 

  37. 

  38. #include <bf_svtools/zforlist.hxx>
    39. 

  39. #include <bf_svtools/zformat.hxx>
    40. 

  40. 

  41. #define _ZFORSCAN_CXX
    42. 

  42. #include "zforscan.hxx"
    43. 

  43. #undef _ZFORSCAN_CXX
    44. 

  44. 

  45. #include "nfsymbol.hxx"
    46. 

  46. 

  47. namespace binfilter
    48. 

  48. {
    49. 

  49. 

  50. const sal_Unicode cNonBreakingSpace = 0xA0;
    51. 

  51. 

  52. namespace
    53. 

  53. {
    54. 

  54.     struct ImplEnglishColors
    55. 

  55.     {
    56. 

  56.         const String* operator()()
    57. 

  57.         {
    58. 

  58.             static const String aEnglishColors[NF_MAX_DEFAULT_COLORS] =
    59. 

  59.             {
    60. 

  60.                 String( RTL_CONSTASCII_USTRINGPARAM( "BLACK" ) ),
    61. 

  61.                 String( RTL_CONSTASCII_USTRINGPARAM( "BLUE" ) ),
    62. 

  62.                 String( RTL_CONSTASCII_USTRINGPARAM( "GREEN" ) ),
    63. 

  63.                 String( RTL_CONSTASCII_USTRINGPARAM( "CYAN" ) ),
    64. 

  64.                 String( RTL_CONSTASCII_USTRINGPARAM( "RED" ) ),
    65. 

  65.                 String( RTL_CONSTASCII_USTRINGPARAM( "MAGENTA" ) ),
    66. 

  66.                 String( RTL_CONSTASCII_USTRINGPARAM( "BROWN" ) ),
    67. 

  67.                 String( RTL_CONSTASCII_USTRINGPARAM( "GREY" ) ),
    68. 

  68.                 String( RTL_CONSTASCII_USTRINGPARAM( "YELLOW" ) ),
    69. 

  69.                 String( RTL_CONSTASCII_USTRINGPARAM( "WHITE" ) )
    70. 

  70.             };
    71. 

  71.             return &aEnglishColors[0];
    72. 

  72.         }
    73. 

  73.     };
    74. 

  74. 

  75.     struct theEnglishColors
    76. 

  76.             : public rtl::StaticAggregate< const String, ImplEnglishColors> {};
    77. 

  77. 

  78. }
    79. 

  79. 

  80. ImpSvNumberformatScan::ImpSvNumberformatScan( SvNumberFormatter* pFormatterP )
    81. 

  81. {
    82. 

  82.     pFormatter = pFormatterP;
    83. 

  83.     bConvertMode = FALSE;
    84. 

  84.     //! All keywords MUST be UPPERCASE!
    85. 

  85.     sKeyword[NF_KEY_E].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "E" ) );        // Exponent
    86. 

  86.     sKeyword[NF_KEY_AMPM].AssignAscii( RTL_CONSTASCII_STRINGPARAM(  "AM/PM" ) );    // AM/PM
    87. 

  87.     sKeyword[NF_KEY_AP].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "A/P" ) );      // AM/PM short
    88. 

  88.     sKeyword[NF_KEY_MI].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "M" ) );        // Minute
    89. 

  89.     sKeyword[NF_KEY_MMI].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "MM" ) );       // Minute 02
    90. 

  90.     sKeyword[NF_KEY_S].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "S" ) );        // Second
    91. 

  91.     sKeyword[NF_KEY_SS].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "SS" ) );       // Second 02
    92. 

  92.     sKeyword[NF_KEY_Q].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "Q" ) );        // Quarter short 'Q'
    93. 

  93.     sKeyword[NF_KEY_QQ].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "QQ" ) );       // Quarter long
    94. 

  94.     sKeyword[NF_KEY_NN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "NN" ) );       // Day of week short
    95. 

  95.     sKeyword[NF_KEY_NNN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "NNN" ) );      // Day of week long
    96. 

  96.     sKeyword[NF_KEY_NNNN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(  "NNNN" ) );     // Day of week long incl. separator
    97. 

  97.     sKeyword[NF_KEY_WW].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "WW" ) );       // Week of year
    98. 

  98.     sKeyword[NF_KEY_CCC].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "CCC" ) );      // Currency abbreviation
    99. 

  99.     bKeywordsNeedInit = TRUE;   // locale dependent keywords
    100. 

  100.     bCompatCurNeedInit = TRUE;  // locale dependent compatibility currency strings
    101. 

  101. 

  102.     StandardColor[0]  =  Color(COL_BLACK);
    103. 

  103.     StandardColor[1]  =  Color(COL_LIGHTBLUE);
    104. 

  104.     StandardColor[2]  =  Color(COL_LIGHTGREEN);
    105. 

  105.     StandardColor[3]  =  Color(COL_LIGHTCYAN);
    106. 

  106.     StandardColor[4]  =  Color(COL_LIGHTRED);
    107. 

  107.     StandardColor[5]  =  Color(COL_LIGHTMAGENTA);
    108. 

  108.     StandardColor[6]  =  Color(COL_BROWN);
    109. 

  109.     StandardColor[7]  =  Color(COL_GRAY);
    110. 

  110.     StandardColor[8]  =  Color(COL_YELLOW);
    111. 

  111.     StandardColor[9]  =  Color(COL_WHITE);
    112. 

  112. 

  113.     pNullDate = new Date(30,12,1899);
    114. 

  114.     nStandardPrec = 2;
    115. 

  115. 

  116.     sErrStr.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "###" ) );
    117. 

  117.     Reset();
    118. 

  118. }
    119. 

  119. 

  120. ImpSvNumberformatScan::~ImpSvNumberformatScan()
    121. 

  121. {
    122. 

  122.     delete pNullDate;
    123. 

  123.     Reset();
    124. 

  124. }
    125. 

  125. 

  126. 

  127. void ImpSvNumberformatScan::ChangeIntl()
    128. 

  128. {
    129. 

  129.     bKeywordsNeedInit = TRUE;
    130. 

  130.     bCompatCurNeedInit = TRUE;
    131. 

  131.     // may be initialized by InitSpecialKeyword()
    132. 

  132.     sKeyword[NF_KEY_TRUE].Erase();
    133. 

  133.     sKeyword[NF_KEY_FALSE].Erase();
    134. 

  134. }
    135. 

  135. 

  136. 

  137. void ImpSvNumberformatScan::InitSpecialKeyword( NfKeywordIndex eIdx ) const
    138. 

  138. {
    139. 

  139.     switch ( eIdx )
    140. 

  140.     {
    141. 

  141.         case NF_KEY_TRUE :
    142. 

  142.             ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_TRUE] =
    143. 

  143.                 pFormatter->GetCharClass()->uppercase(
    144. 

  144.                 pFormatter->GetLocaleData()->getTrueWord() );
    145. 

  145.             if ( !sKeyword[NF_KEY_TRUE].Len() )
    146. 

  146.             {
    147. 

  147.                 DBG_ERRORFILE( "InitSpecialKeyword: TRUE_WORD?" );
    148. 

  148.                 ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_TRUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TRUE" ) );
    149. 

  149.             }
    150. 

  150.         break;
    151. 

  151.         case NF_KEY_FALSE :
    152. 

  152.             ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_FALSE] =
    153. 

  153.                 pFormatter->GetCharClass()->uppercase(
    154. 

  154.                 pFormatter->GetLocaleData()->getFalseWord() );
    155. 

  155.             if ( !sKeyword[NF_KEY_FALSE].Len() )
    156. 

  156.             {
    157. 

  157.                 DBG_ERRORFILE( "InitSpecialKeyword: FALSE_WORD?" );
    158. 

  158.                 ((ImpSvNumberformatScan*)this)->sKeyword[NF_KEY_FALSE].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "FALSE" ) );
    159. 

  159.             }
    160. 

  160.         break;
    161. 

  161.         default:
    162. 

  162.             DBG_ERRORFILE( "InitSpecialKeyword: unknown request" );
    163. 

  163.     }
    164. 

  164. }
    165. 

  165. 

  166. 

  167. void ImpSvNumberformatScan::InitCompatCur() const
    168. 

  168. {
    169. 

  169.     ImpSvNumberformatScan* pThis = (ImpSvNumberformatScan*)this;
    170. 

  170.     // currency symbol for old style ("automatic") compatibility format codes
    171. 

  171.     pFormatter->GetCompatibilityCurrency( pThis->sCurSymbol, pThis->sCurAbbrev );
    172. 

  172.     // currency symbol upper case
    173. 

  173.     pThis->sCurString = pFormatter->GetCharClass()->uppercase( sCurSymbol );
    174. 

  174.     bCompatCurNeedInit = FALSE;
    175. 

  175. }
    176. 

  176. 

  177. 

  178. void ImpSvNumberformatScan::InitKeywords() const
    179. 

  179. {
    180. 

  180.     if ( !bKeywordsNeedInit )
    181. 

  181.         return ;
    182. 

  182.     ((ImpSvNumberformatScan*)this)->SetDependentKeywords();
    183. 

  183.     bKeywordsNeedInit = FALSE;
    184. 

  184. }
    185. 

  185. 

  186. 

  187. void ImpSvNumberformatScan::SetDependentKeywords()
    188. 

  188. {
    189. 

  189.     using namespace ::com::sun::star;
    190. 

  190.     using namespace ::com::sun::star::uno;
    191. 

  191. 

  192.     const CharClass* pCharClass = pFormatter->GetCharClass();
    193. 

  193.     const LocaleDataWrapper* pLocaleData = pFormatter->GetLocaleData();
    194. 

  194.     // #80023# be sure to generate keywords for the loaded Locale, not for the
    195. 

  195.     // requested Locale, otherwise number format codes might not match
    196. 

  196.     lang::Locale aLoadedLocale = pLocaleData->getLoadedLocale();
    197. 

  197.     LanguageType eLang = MsLangId::convertLocaleToLanguage( aLoadedLocale );
    198. 

  198.     NumberFormatCodeWrapper aNumberFormatCode( pFormatter->GetServiceManager(), aLoadedLocale );
    199. 

  199. 

  200.     i18n::NumberFormatCode aFormat = aNumberFormatCode.getFormatCode( NF_NUMBER_STANDARD );
    201. 

  201.     sNameStandardFormat = aFormat.Code;
    202. 

  202.     sKeyword[NF_KEY_GENERAL] = pCharClass->uppercase( sNameStandardFormat );
    203. 

  203. 

  204.     // preset new calendar keywords
    205. 

  205.     sKeyword[NF_KEY_AAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "AAA" ) );
    206. 

  206.     sKeyword[NF_KEY_AAAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM(  "AAAA" ) );
    207. 

  207.     sKeyword[NF_KEY_EC].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "E" ) );
    208. 

  208.     sKeyword[NF_KEY_EEC].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "EE" ) );
    209. 

  209.     sKeyword[NF_KEY_G].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "G" ) );
    210. 

  210.     sKeyword[NF_KEY_GG].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "GG" ) );
    211. 

  211.     sKeyword[NF_KEY_GGG].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "GGG" ) );
    212. 

  212.     sKeyword[NF_KEY_R].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "R" ) );
    213. 

  213.     sKeyword[NF_KEY_RR].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "RR" ) );
    214. 

  214. 

  215.     // Thai T NatNum special. Other locale's small letter 't' results in upper
    216. 

  216.     // case comparison not matching but length does in conversion mode. Ugly.
    217. 

  217.     if (eLang == LANGUAGE_THAI)
    218. 

  218.         sKeyword[NF_KEY_THAI_T].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T"));
    219. 

  219.     else
    220. 

  220.         sKeyword[NF_KEY_THAI_T].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "t"));
    221. 

  221. 

  222.     switch ( eLang )
    223. 

  223.     {
    224. 

  224.         case LANGUAGE_GERMAN:
    225. 

  225.         case LANGUAGE_GERMAN_SWISS:
    226. 

  226.         case LANGUAGE_GERMAN_AUSTRIAN:
    227. 

  227.         case LANGUAGE_GERMAN_LUXEMBOURG:
    228. 

  228.         case LANGUAGE_GERMAN_LIECHTENSTEIN:
    229. 

  229.         {
    230. 

  230.             //! all capital letters
    231. 

  231.             sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM(         "M" ) );            // month 1
    232. 

  232.             sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM(        "MM" ) );           // month 01
    233. 

  233.             sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM(       "MMM" ) );      // month Jan
    234. 

  234.             sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "MMMM" ) ); // month Januar
    235. 

  235.             sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "MMMMM" ) );// month J
    236. 

  236.             sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM(         "H" ) );            // hour 2
    237. 

  237.             sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM(        "HH" ) );           // hour 02
    238. 

  238.             sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM(         "T" ) );
    239. 

  239.             sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM(        "TT" ) );
    240. 

  240.             sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM(       "TTT" ) );
    241. 

  241.             sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "TTTT" ) );
    242. 

  242.             sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM(        "JJ" ) );
    243. 

  243.             sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "JJJJ" ) );
    244. 

  244.             sKeyword[NF_KEY_BOOLEAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "LOGISCH" ) );
    245. 

  245.             sKeyword[NF_KEY_COLOR].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "FARBE" ) );
    246. 

  246.             sKeyword[NF_KEY_BLACK].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "SCHWARZ" ) );
    247. 

  247.             sKeyword[NF_KEY_BLUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "BLAU" ) );
    248. 

  248.             sKeyword[NF_KEY_GREEN] = UniString( "GR" "\xDC" "N", RTL_TEXTENCODING_ISO_8859_1 );
    249. 

  249.             sKeyword[NF_KEY_CYAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "CYAN" ) );
    250. 

  250.             sKeyword[NF_KEY_RED].AssignAscii( RTL_CONSTASCII_STRINGPARAM(       "ROT" ) );
    251. 

  251.             sKeyword[NF_KEY_MAGENTA].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "MAGENTA" ) );
    252. 

  252.             sKeyword[NF_KEY_BROWN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "BRAUN" ) );
    253. 

  253.             sKeyword[NF_KEY_GREY].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "GRAU" ) );
    254. 

  254.             sKeyword[NF_KEY_YELLOW].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "GELB" ) );
    255. 

  255.             sKeyword[NF_KEY_WHITE].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "WEISS" ) );
    256. 

  256.         }
    257. 

  257.         break;
    258. 

  258.         default:
    259. 

  259.         {
    260. 

  260.             // day
    261. 

  261.             switch ( eLang )
    262. 

  262.             {
    263. 

  263.                 case LANGUAGE_ITALIAN       :
    264. 

  264.                 case LANGUAGE_ITALIAN_SWISS :
    265. 

  265.                     sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "G" ) );
    266. 

  266.                     sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GG" ) );
    267. 

  267.                     sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGG" ) );
    268. 

  268.                     sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "GGGG" ) );
    269. 

  269.                     // must exchange the era code, same as Xcl
    270. 

  270.                     sKeyword[NF_KEY_G].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "X" ) );
    271. 

  271.                     sKeyword[NF_KEY_GG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "XX" ) );
    272. 

  272.                     sKeyword[NF_KEY_GGG].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "XXX" ) );
    273. 

  273.                 break;
    274. 

  274.                 case LANGUAGE_FRENCH            :
    275. 

  275.                 case LANGUAGE_FRENCH_BELGIAN    :
    276. 

  276.                 case LANGUAGE_FRENCH_CANADIAN   :
    277. 

  277.                 case LANGUAGE_FRENCH_SWISS      :
    278. 

  278.                 case LANGUAGE_FRENCH_LUXEMBOURG :
    279. 

  279.                 case LANGUAGE_FRENCH_MONACO     :
    280. 

  280.                     sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "J" ) );
    281. 

  281.                     sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
    282. 

  282.                     sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJ" ) );
    283. 

  283.                     sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
    284. 

  284.                 break;
    285. 

  285.                 case LANGUAGE_FINNISH :
    286. 

  286.                     sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "P" ) );
    287. 

  287.                     sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PP" ) );
    288. 

  288.                     sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PPP" ) );
    289. 

  289.                     sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "PPPP" ) );
    290. 

  290.                 break;
    291. 

  291.                 default:
    292. 

  292.                     sKeyword[NF_KEY_D].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D" ) );
    293. 

  293.                     sKeyword[NF_KEY_DD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DD" ) );
    294. 

  294.                     sKeyword[NF_KEY_DDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDD" ) );
    295. 

  295.                     sKeyword[NF_KEY_DDDD].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "DDDD" ) );
    296. 

  296.             }
    297. 

  297.             // month
    298. 

  298.             switch ( eLang )
    299. 

  299.             {
    300. 

  300.                 case LANGUAGE_FINNISH :
    301. 

  301.                     sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "K" ) );
    302. 

  302.                     sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KK" ) );
    303. 

  303.                     sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKK" ) );
    304. 

  304.                     sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKKK" ) );
    305. 

  305.                     sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "KKKKK" ) );
    306. 

  306.                 break;
    307. 

  307.                 default:
    308. 

  308.                     sKeyword[NF_KEY_M].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "M" ) );
    309. 

  309.                     sKeyword[NF_KEY_MM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MM" ) );
    310. 

  310.                     sKeyword[NF_KEY_MMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMM" ) );
    311. 

  311.                     sKeyword[NF_KEY_MMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMM" ) );
    312. 

  312.                     sKeyword[NF_KEY_MMMMM].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "MMMMM" ) );
    313. 

  313.             }
    314. 

  314.             // year
    315. 

  315.             switch ( eLang )
    316. 

  316.             {
    317. 

  317.                 case LANGUAGE_ITALIAN       :
    318. 

  318.                 case LANGUAGE_ITALIAN_SWISS :
    319. 

  319.                 case LANGUAGE_FRENCH            :
    320. 

  320.                 case LANGUAGE_FRENCH_BELGIAN    :
    321. 

  321.                 case LANGUAGE_FRENCH_CANADIAN   :
    322. 

  322.                 case LANGUAGE_FRENCH_SWISS      :
    323. 

  323.                 case LANGUAGE_FRENCH_LUXEMBOURG :
    324. 

  324.                 case LANGUAGE_FRENCH_MONACO     :
    325. 

  325.                 case LANGUAGE_PORTUGUESE           :
    326. 

  326.                 case LANGUAGE_PORTUGUESE_BRAZILIAN :
    327. 

  327.                 case LANGUAGE_SPANISH_MODERN      :
    328. 

  328.                 case LANGUAGE_SPANISH_DATED       :
    329. 

  329.                 case LANGUAGE_SPANISH_MEXICAN     :
    330. 

  330.                 case LANGUAGE_SPANISH_GUATEMALA   :
    331. 

  331.                 case LANGUAGE_SPANISH_COSTARICA   :
    332. 

  332.                 case LANGUAGE_SPANISH_PANAMA      :
    333. 

  333.                 case LANGUAGE_SPANISH_DOMINICAN_REPUBLIC :
    334. 

  334.                 case LANGUAGE_SPANISH_VENEZUELA   :
    335. 

  335.                 case LANGUAGE_SPANISH_COLOMBIA    :
    336. 

  336.                 case LANGUAGE_SPANISH_PERU        :
    337. 

  337.                 case LANGUAGE_SPANISH_ARGENTINA   :
    338. 

  338.                 case LANGUAGE_SPANISH_ECUADOR     :
    339. 

  339.                 case LANGUAGE_SPANISH_CHILE       :
    340. 

  340.                 case LANGUAGE_SPANISH_URUGUAY     :
    341. 

  341.                 case LANGUAGE_SPANISH_PARAGUAY    :
    342. 

  342.                 case LANGUAGE_SPANISH_BOLIVIA     :
    343. 

  343.                 case LANGUAGE_SPANISH_EL_SALVADOR :
    344. 

  344.                 case LANGUAGE_SPANISH_HONDURAS    :
    345. 

  345.                 case LANGUAGE_SPANISH_NICARAGUA   :
    346. 

  346.                 case LANGUAGE_SPANISH_PUERTO_RICO :
    347. 

  347.                     sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AA" ) );
    348. 

  348.                     sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "AAAA" ) );
    349. 

  349.                     // must exchange the day of week name code, same as Xcl
    350. 

  350.                     sKeyword[NF_KEY_AAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "OOO" ) );
    351. 

  351.                     sKeyword[NF_KEY_AAAA].AssignAscii( RTL_CONSTASCII_STRINGPARAM(  "OOOO" ) );
    352. 

  352.                 break;
    353. 

  353.                 case LANGUAGE_DUTCH         :
    354. 

  354.                 case LANGUAGE_DUTCH_BELGIAN :
    355. 

  355.                     sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJ" ) );
    356. 

  356.                     sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "JJJJ" ) );
    357. 

  357.                 break;
    358. 

  358.                 case LANGUAGE_FINNISH :
    359. 

  359.                     sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "VV" ) );
    360. 

  360.                     sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "VVVV" ) );
    361. 

  361.                 break;
    362. 

  362.                 default:
    363. 

  363.                     sKeyword[NF_KEY_YY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YY" ) );
    364. 

  364.                     sKeyword[NF_KEY_YYYY].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "YYYY" ) );
    365. 

  365.             }
    366. 

  366.             // hour
    367. 

  367.             switch ( eLang )
    368. 

  368.             {
    369. 

  369.                 case LANGUAGE_DUTCH         :
    370. 

  370.                 case LANGUAGE_DUTCH_BELGIAN :
    371. 

  371.                     sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "U" ) );
    372. 

  372.                     sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "UU" ) );
    373. 

  373.                 break;
    374. 

  374.                 case LANGUAGE_FINNISH :
    375. 

  375.                 case LANGUAGE_SWEDISH         :
    376. 

  376.                 case LANGUAGE_SWEDISH_FINLAND :
    377. 

  377.                 case LANGUAGE_DANISH :
    378. 

  378.                 case LANGUAGE_NORWEGIAN         :
    379. 

  379.                 case LANGUAGE_NORWEGIAN_BOKMAL  :
    380. 

  380.                 case LANGUAGE_NORWEGIAN_NYNORSK :
    381. 

  381.                     sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "T" ) );
    382. 

  382.                     sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "TT" ) );
    383. 

  383.                 break;
    384. 

  384.                 default:
    385. 

  385.                     sKeyword[NF_KEY_H].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "H" ) );
    386. 

  386.                     sKeyword[NF_KEY_HH].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "HH" ) );
    387. 

  387.             }
    388. 

  388.             // boolean
    389. 

  389.             sKeyword[NF_KEY_BOOLEAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM( "BOOLEAN" ) );
    390. 

  390.             // colours
    391. 

  391.             sKeyword[NF_KEY_COLOR].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "COLOR" ) );
    392. 

  392.             sKeyword[NF_KEY_BLACK].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "BLACK" ) );
    393. 

  393.             sKeyword[NF_KEY_BLUE].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "BLUE" ) );
    394. 

  394.             sKeyword[NF_KEY_GREEN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "GREEN" ) );
    395. 

  395.             sKeyword[NF_KEY_CYAN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "CYAN" ) );
    396. 

  396.             sKeyword[NF_KEY_RED].AssignAscii( RTL_CONSTASCII_STRINGPARAM(       "RED" ) );
    397. 

  397.             sKeyword[NF_KEY_MAGENTA].AssignAscii( RTL_CONSTASCII_STRINGPARAM(   "MAGENTA" ) );
    398. 

  398.             sKeyword[NF_KEY_BROWN].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "BROWN" ) );
    399. 

  399.             sKeyword[NF_KEY_GREY].AssignAscii( RTL_CONSTASCII_STRINGPARAM(      "GREY" ) );
    400. 

  400.             sKeyword[NF_KEY_YELLOW].AssignAscii( RTL_CONSTASCII_STRINGPARAM(    "YELLOW" ) );
    401. 

  401.             sKeyword[NF_KEY_WHITE].AssignAscii( RTL_CONSTASCII_STRINGPARAM(     "WHITE" ) );
    402. 

  402.         }
    403. 

  403.         break;
    404. 

  404.     }
    405. 

  405. 

  406.     // boolean keyords
    407. 

  407.     InitSpecialKeyword( NF_KEY_TRUE );
    408. 

  408.     InitSpecialKeyword( NF_KEY_FALSE );
    409. 

  409. 

  410.     // compatibility currency strings
    411. 

  411.     InitCompatCur();
    412. 

  412. }
    413. 

  413. 

  414. 

  415. void ImpSvNumberformatScan::ChangeNullDate(USHORT nDay, USHORT nMonth, USHORT nYear)
    416. 

  416. {
    417. 

  417.     if ( pNullDate )
    418. 

  418.         *pNullDate = Date(nDay, nMonth, nYear);
    419. 

  419.     else
    420. 

  420.         pNullDate = new Date(nDay, nMonth, nYear);
    421. 

  421. }
    422. 

  422. 

  423. void ImpSvNumberformatScan::ChangeStandardPrec(short nPrec)
    424. 

  424. {
    425. 

  425.     nStandardPrec = nPrec;
    426. 

  426. }
    427. 

  427. 

  428. Color* ImpSvNumberformatScan::GetColor(String& sStr)
    429. 

  429. {
    430. 

  430.     String sString = pFormatter->GetCharClass()->uppercase(sStr);
    431. 

  431.     const String* pKeyword = GetKeywords();
    432. 

  432.     size_t i = 0;
    433. 

  433.     while (i < NF_MAX_DEFAULT_COLORS &&
    434. 

  434.            sString != pKeyword[NF_KEY_FIRSTCOLOR+i] )
    435. 

  435.         i++;
    436. 

  436.     if ( i >= NF_MAX_DEFAULT_COLORS )
    437. 

  437.     {
    438. 

  438.         const String* pEnglishColors = theEnglishColors::get();
    439. 

  439.         size_t j = 0;
    440. 

  440.         while ( j < NF_MAX_DEFAULT_COLORS &&
    441. 

  441.                 sString != pEnglishColors[j] )
    442. 

  442.             ++j;
    443. 

  443.         if ( j < NF_MAX_DEFAULT_COLORS )
    444. 

  444.             i = j;
    445. 

  445.     }
    446. 

  446.     if (i >= NF_MAX_DEFAULT_COLORS)
    447. 

  447.     {
    448. 

  448.         const String& rColorWord = pKeyword[NF_KEY_COLOR];
    449. 

  449.         xub_StrLen nPos = sString.Match(rColorWord);
    450. 

  450.         if (nPos > 0)
    451. 

  451.         {
    452. 

  452.             sStr.Erase(0, nPos);
    453. 

  453.             sStr.EraseLeadingChars();
    454. 

  454.             sStr.EraseTrailingChars();
    455. 

  455.             if (bConvertMode)
    456. 

  456.             {
    457. 

  457.                 pFormatter->ChangeIntl(eNewLnge);
    458. 

  458.                 sStr.Insert( GetKeywords()[NF_KEY_COLOR], 0 );  // Color -> FARBE
    459. 

  459.                 pFormatter->ChangeIntl(eTmpLnge);
    460. 

  460.             }
    461. 

  461.             else
    462. 

  462.                 sStr.Insert(rColorWord,0);
    463. 

  463.             sString.Erase(0, nPos);
    464. 

  464.             sString.EraseLeadingChars();
    465. 

  465.             sString.EraseTrailingChars();
    466. 

  466. 

  467.             if ( CharClass::isAsciiNumeric( sString ) )
    468. 

  468.             {
    469. 

  469.                 long nIndex = sString.ToInt32();
    470. 

  470.                 if (nIndex > 0 && nIndex <= 64)
    471. 

  471.                     return pFormatter->GetUserDefColor((USHORT)nIndex-1);
    472. 

  472.                 else
    473. 

  473.                     return NULL;
    474. 

  474.             }
    475. 

  475.             else
    476. 

  476.                 return NULL;
    477. 

  477.         }
    478. 

  478.         else
    479. 

  479.             return NULL;
    480. 

  480.     }
    481. 

  481.     else
    482. 

  482.     {
    483. 

  483.         sStr.Erase();
    484. 

  484.         if (bConvertMode)
    485. 

  485.         {
    486. 

  486.             pFormatter->ChangeIntl(eNewLnge);
    487. 

  487.             sStr = GetKeywords()[NF_KEY_FIRSTCOLOR+i];           // red -> rot
    488. 

  488.             pFormatter->ChangeIntl(eTmpLnge);
    489. 

  489.         }
    490. 

  490.         else
    491. 

  491.             sStr = pKeyword[NF_KEY_FIRSTCOLOR+i];
    492. 

  492. 

  493.         return &(StandardColor[i]);
    494. 

  494.     }
    495. 

  495. }
    496. 

  496. 

  497. 

  498. short ImpSvNumberformatScan::GetKeyWord( const String& sSymbol, xub_StrLen nPos )
    499. 

  499. {
    500. 

  500.     String sString = pFormatter->GetCharClass()->uppercase( sSymbol, nPos, sSymbol.Len() - nPos );
    501. 

  501.     const String* pKeyword = GetKeywords();
    502. 

  502.     // #77026# for the Xcl perverts: the GENERAL keyword is recognized anywhere
    503. 

  503.     if ( sString.Search( pKeyword[NF_KEY_GENERAL] ) == 0 )
    504. 

  504.         return NF_KEY_GENERAL;
    505. 

  505.     //! MUST be a reverse search to find longer strings first
    506. 

  506.     short i = NF_KEYWORD_ENTRIES_COUNT-1;
    507. 

  507.     BOOL bFound = FALSE;
    508. 

  508.     for ( ; i > NF_KEY_LASTKEYWORD_SO5; --i )
    509. 

  509.     {
    510. 

  510.         bFound = sString.Search(pKeyword[i]) == 0;
    511. 

  511.         if ( bFound )
    512. 

  512.         {
    513. 

  513.             break;
    514. 

  514.         }
    515. 

  515.     }
    516. 

  516.     // new keywords take precedence over old keywords
    517. 

  517.     if ( !bFound )
    518. 

  518.     {   // skip the gap of colors et al between new and old keywords and search on
    519. 

  519.         i = NF_KEY_LASTKEYWORD;
    520. 

  520.         while ( i > 0 && sString.Search(pKeyword[i]) != 0 )
    521. 

  521.             i--;
    522. 

  522.         if ( i > NF_KEY_LASTOLDKEYWORD && sString != pKeyword[i] )
    523. 

  523.         {   // found something, but maybe it's something else?
    524. 

  524.             // e.g. new NNN is found in NNNN, for NNNN we must search on
    525. 

  525.             short j = i - 1;
    526. 

  526.             while ( j > 0 && sString.Search(pKeyword[j]) != 0 )
    527. 

  527.                 j--;
    528. 

  528.             if ( j && pKeyword[j].Len() > pKeyword[i].Len() )
    529. 

  529.                 return j;
    530. 

  530.         }
    531. 

  531.     }
    532. 

  532.     // The Thai T NatNum modifier during Xcl import.
    533. 

  533.     if (i == 0 && bConvertMode && sString.GetChar(0) == 'T' && eTmpLnge ==
    534. 

  534.             LANGUAGE_ENGLISH_US && MsLangId::getRealLanguage( eNewLnge) ==
    535. 

  535.             LANGUAGE_THAI)
    536. 

  536.         i = NF_KEY_THAI_T;
    537. 

  537.     return i;       // 0 => not found
    538. 

  538. }
    539. 

  539. 

  540. //---------------------------------------------------------------------------
    541. 

  541. // Next_Symbol
    542. 

  542. //---------------------------------------------------------------------------
    543. 

  543. // Zerlegt die Eingabe in Symbole fuer die weitere
    544. 

  544. // Verarbeitung (Turing-Maschine).
    545. 

  545. //---------------------------------------------------------------------------
    546. 

  546. // Ausgangs Zustand = SsStart
    547. 

  547. //---------------+-------------------+-----------------------+---------------
    548. 

  548. // Alter Zustand | gelesenes Zeichen | Aktion                | Neuer Zustand
    549. 

  549. //---------------+-------------------+-----------------------+---------------
    550. 

  550. // SsStart       | Buchstabe         | Symbol=Zeichen        | SsGetWord
    551. 

  551. //               |    "              | Typ = String          | SsGetString
    552. 

  552. //               |    \              | Typ = String          | SsGetChar
    553. 

  553. //               |    *              | Typ = Star            | SsGetStar
    554. 

  554. //               |    _              | Typ = Blank           | SsGetBlank
    555. 

  555. //               | @ # 0 ? / . , % [ | Symbol = Zeichen;     |
    556. 

  556. //               | ] ' Blank         | Typ = Steuerzeichen   | SsStop
    557. 

  557. //               | $ - + ( ) :       | Typ    = String;      |
    558. 

  558. //               | |                 | Typ    = Comment      | SsStop
    559. 

  559. //               | Sonst             | Symbol = Zeichen      | SsStop
    560. 

  560. //---------------|-------------------+-----------------------+---------------
    561. 

  561. // SsGetChar     | Sonst             | Symbol=Zeichen        | SsStop
    562. 

  562. //---------------+-------------------+-----------------------+---------------
    563. 

  563. // GetString     | "                 |                       | SsStop
    564. 

  564. //               | Sonst             | Symbol+=Zeichen       | GetString
    565. 

  565. //---------------+-------------------+-----------------------+---------------
    566. 

  566. // SsGetWord     | Buchstabe         | Symbol += Zeichen     |
    567. 

  567. //               | + -        (E+ E-)| Symbol += Zeichen     | SsStop
    568. 

  568. //               | /          (AM/PM)| Symbol += Zeichen     |
    569. 

  569. //               | Sonst             | Pos--, if Key Typ=Word| SsStop
    570. 

  570. //---------------+-------------------+-----------------------+---------------
    571. 

  571. // SsGetStar     | Sonst             | Symbol+=Zeichen       | SsStop
    572. 

  572. //               |                   | markiere Sonderfall * |
    573. 

  573. //---------------+-------------------+-----------------------+---------------
    574. 

  574. // SsGetBlank    | Sonst             | Symbol+=Zeichen       | SsStop
    575. 

  575. //               |                   | markiere Sonderfall _ |
    576. 

  576. //---------------+-------------------+-----------------------+---------------
    577. 

  577. // Wurde im State SsGetWord ein Schluesselwort erkannt (auch als
    578. 

  578. // Anfangsteilwort des Symbols)
    579. 

  579. // so werden die restlichen Buchstaben zurueckgeschrieben !!
    580. 

  580. 

  581. enum ScanState
    582. 

  582. {
    583. 

  583.     SsStop      = 0,
    584. 

  584.     SsStart     = 1,
    585. 

  585.     SsGetChar   = 2,
    586. 

  586.     SsGetString = 3,
    587. 

  587.     SsGetWord   = 4,
    588. 

  588.     SsGetStar   = 5,
    589. 

  589.     SsGetBlank  = 6
    590. 

  590. };
    591. 

  591. 

  592. short ImpSvNumberformatScan::Next_Symbol( const String& rStr,
    593. 

  593.             xub_StrLen& nPos, String& sSymbol )
    594. 

  594. {
    595. 

  595.     if ( bKeywordsNeedInit )
    596. 

  596.         InitKeywords();
    597. 

  597.     const CharClass* pChrCls = pFormatter->GetCharClass();
    598. 

  598.     const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
    599. 

  599.     const xub_StrLen nStart = nPos;
    600. 

  600.     short eType = 0;
    601. 

  601.     ScanState eState = SsStart;
    602. 

  602.     sSymbol.Erase();
    603. 

  603.     while ( nPos < rStr.Len() && eState != SsStop )
    604. 

  604.     {
    605. 

  605.         sal_Unicode cToken = rStr.GetChar( nPos++ );
    606. 

  606.         switch (eState)
    607. 

  607.         {
    608. 

  608.             case SsStart:
    609. 

  609.             {
    610. 

  610.                 // Fetch any currency longer than one character and don't get
    611. 

  611.                 // confused later on by "E/" or other combinations of letters
    612. 

  612.                 // and meaningful symbols. Necessary for old automatic currency.
    613. 

  613.                 // #96158# But don't do it if we're starting a "[...]" section,
    614. 

  614.                 // for example a "[$...]" new currency symbol to not parse away
    615. 

  615.                 // "$U" (symbol) of "[$UYU]" (abbreviation).
    616. 

  616.                 if ( nCurrPos != STRING_NOTFOUND && sCurString.Len() > 1 &&
    617. 

  617.                         nPos-1 + sCurString.Len() <= rStr.Len() &&
    618. 

  618.                         !(nPos > 1 && rStr.GetChar( nPos-2 ) == '[') )
    619. 

  619.                 {
    620. 

  620.                     String aTest( rStr.Copy( nPos-1, sCurString.Len() ) );
    621. 

  621.                     aTest = pChrCls->uppercase( aTest );
    622. 

  622.                     if ( aTest == sCurString )
    623. 

  623.                     {
    624. 

  624.                         sSymbol = rStr.Copy( --nPos, sCurString.Len() );
    625. 

  625.                         nPos = nPos + sSymbol.Len();
    626. 

  626.                         eState = SsStop;
    627. 

  627.                         eType = NF_SYMBOLTYPE_STRING;
    628. 

  628.                         return eType;
    629. 

  629.                     }
    630. 

  630.                 }
    631. 

  631.                 switch (cToken)
    632. 

  632.                 {
    633. 

  633.                     case '#':
    634. 

  634.                     case '0':
    635. 

  635.                     case '?':
    636. 

  636.                     case '%':
    637. 

  637.                     case '@':
    638. 

  638.                     case '[':
    639. 

  639.                     case ']':
    640. 

  640.                     case ',':
    641. 

  641.                     case '.':
    642. 

  642.                     case '/':
    643. 

  643.                     case '\'':
    644. 

  644.                     case ' ':
    645. 

  645.                     case ':':
    646. 

  646.                     case '-':
    647. 

  647.                     {
    648. 

  648.                         eType = NF_SYMBOLTYPE_DEL;
    649. 

  649.                         sSymbol += cToken;
    650. 

  650.                         eState = SsStop;
    651. 

  651.                     }
    652. 

  652.                     break;
    653. 

  653.                     case '*':
    654. 

  654.                     {
    655. 

  655.                         eType = NF_SYMBOLTYPE_STAR;
    656. 

  656.                         sSymbol += cToken;
    657. 

  657.                         eState = SsGetStar;
    658. 

  658.                     }
    659. 

  659.                     break;
    660. 

  660.                     case '_':
    661. 

  661.                     {
    662. 

  662.                         eType = NF_SYMBOLTYPE_BLANK;
    663. 

  663.                         sSymbol += cToken;
    664. 

  664.                         eState = SsGetBlank;
    665. 

  665.                     }
    666. 

  666.                     break;
    667. 

  667. #if NF_COMMENT_IN_FORMATSTRING
    668. 

  668.                     case '{':
    669. 

  669.                         eType = NF_SYMBOLTYPE_COMMENT;
    670. 

  670.                         eState = SsStop;
    671. 

  671.                         sSymbol.Append( rStr.GetBuffer() + (nPos-1), rStr.Len() - (nPos-1) );
    672. 

  672.                         nPos = rStr.Len();
    673. 

  673.                     break;
    674. 

  674. #endif
    675. 

  675.                     case '"':
    676. 

  676.                         eType = NF_SYMBOLTYPE_STRING;
    677. 

  677.                         eState = SsGetString;
    678. 

  678.                         sSymbol += cToken;
    679. 

  679.                     break;
    680. 

  680.                     case '\\':
    681. 

  681.                         eType = NF_SYMBOLTYPE_STRING;
    682. 

  682.                         eState = SsGetChar;
    683. 

  683.                         sSymbol += cToken;
    684. 

  684.                     break;
    685. 

  685.                     case '$':
    686. 

  686.                     case '+':
    687. 

  687.                     case '(':
    688. 

  688.                     case ')':
    689. 

  689.                         eType = NF_SYMBOLTYPE_STRING;
    690. 

  690.                         eState = SsStop;
    691. 

  691.                         sSymbol += cToken;
    692. 

  692.                     break;
    693. 

  693.                     default :
    694. 

  694.                     {
    695. 

  695.                         if (StringEqualsChar( pFormatter->GetNumDecimalSep(), cToken) ||
    696. 

  696.                                 StringEqualsChar( pFormatter->GetNumThousandSep(), cToken) ||
    697. 

  697.                                 StringEqualsChar( pFormatter->GetDateSep(), cToken) ||
    698. 

  698.                                 StringEqualsChar( pLoc->getTimeSep(), cToken) ||
    699. 

  699.                                 StringEqualsChar( pLoc->getTime100SecSep(), cToken))
    700. 

  700.                         {
    701. 

  701.                             // Another separator than pre-known ASCII
    702. 

  702.                             eType = NF_SYMBOLTYPE_DEL;
    703. 

  703.                             sSymbol += cToken;
    704. 

  704.                             eState = SsStop;
    705. 

  705.                         }
    706. 

  706.                         else if ( pChrCls->isLetter( rStr, nPos-1 ) )
    707. 

  707.                         {
    708. 

  708.                             short nTmpType = GetKeyWord( rStr, nPos-1 );
    709. 

  709.                             if ( nTmpType )
    710. 

  710.                             {
    711. 

  711.                                 BOOL bCurrency = FALSE;
    712. 

  712.                                 // "Automatic" currency may start with keyword,
    713. 

  713.                                 // like "R" (Rand) and 'R' (era)
    714. 

  714.                                 if ( nCurrPos != STRING_NOTFOUND &&
    715. 

  715.                                     nPos-1 + sCurString.Len() <= rStr.Len() &&
    716. 

  716.                                     sCurString.Search( sKeyword[nTmpType] ) == 0 )
    717. 

  717.                                 {
    718. 

  718.                                     String aTest( rStr.Copy( nPos-1, sCurString.Len() ) );
    719. 

  719.                                     aTest = pChrCls->uppercase( aTest );
    720. 

  720.                                     if ( aTest == sCurString )
    721. 

  721.                                         bCurrency = TRUE;
    722. 

  722.                                 }
    723. 

  723.                                 if ( bCurrency )
    724. 

  724.                                 {
    725. 

  725.                                     eState = SsGetWord;
    726. 

  726.                                     sSymbol += cToken;
    727. 

  727.                                 }
    728. 

  728.                                 else
    729. 

  729.                                 {
    730. 

  730.                                     eType = nTmpType;
    731. 

  731.                                     xub_StrLen nLen = sKeyword[eType].Len();
    732. 

  732.                                     sSymbol = rStr.Copy( nPos-1, nLen );
    733. 

  733.                                     if ( eType == NF_KEY_E || IsAmbiguousE( eType ) )
    734. 

  734.                                     {
    735. 

  735.                                         sal_Unicode cNext = rStr.GetChar(nPos);
    736. 

  736.                                         switch ( cNext )
    737. 

  737.                                         {
    738. 

  738.                                             case '+' :
    739. 

  739.                                             case '-' :  // E+ E- combine to one symbol
    740. 

  740.                                                 sSymbol += cNext;
    741. 

  741.                                                 eType = NF_KEY_E;
    742. 

  742.                                                 nPos++;
    743. 

  743.                                             break;
    744. 

  744.                                             case '0' :
    745. 

  745.                                             case '#' :  // scientific E without sign
    746. 

  746.                                                 eType = NF_KEY_E;
    747. 

  747.                                             break;
    748. 

  748.                                         }
    749. 

  749.                                     }
    750. 

  750.                                     nPos--;
    751. 

  751.                                     nPos = nPos + nLen;
    752. 

  752.                                     eState = SsStop;
    753. 

  753.                                 }
    754. 

  754.                             }
    755. 

  755.                             else
    756. 

  756.                             {
    757. 

  757.                                 eState = SsGetWord;
    758. 

  758.                                 sSymbol += cToken;
    759. 

  759.                             }
    760. 

  760.                         }
    761. 

  761.                         else
    762. 

  762.                         {
    763. 

  763.                             eType = NF_SYMBOLTYPE_STRING;
    764. 

  764.                             eState = SsStop;
    765. 

  765.                             sSymbol += cToken;
    766. 

  766.                         }
    767. 

  767.                     }
    768. 

  768.                     break;
    769. 

  769.                 }
    770. 

  770.             }
    771. 

  771.             break;
    772. 

  772.             case SsGetChar:
    773. 

  773.             {
    774. 

  774.                 sSymbol += cToken;
    775. 

  775.                 eState = SsStop;
    776. 

  776.             }
    777. 

  777.             break;
    778. 

  778.             case SsGetString:
    779. 

  779.             {
    780. 

  780.                 if (cToken == '"')
    781. 

  781.                     eState = SsStop;
    782. 

  782.                 sSymbol += cToken;
    783. 

  783.             }
    784. 

  784.             break;
    785. 

  785.             case SsGetWord:
    786. 

  786.             {
    787. 

  787.                 if ( pChrCls->isLetter( rStr, nPos-1 ) )
    788. 

  788.                 {
    789. 

  789.                     short nTmpType = GetKeyWord( rStr, nPos-1 );
    790. 

  790.                     if ( nTmpType )
    791. 

  791.                     {   // beginning of keyword, stop scan and put back
    792. 

  792.                         eType = NF_SYMBOLTYPE_STRING;
    793. 

  793.                         eState = SsStop;
    794. 

  794.                         nPos--;
    795. 

  795.                     }
    796. 

  796.                     else
    797. 

  797.                         sSymbol += cToken;
    798. 

  798.                 }
    799. 

  799.                 else
    800. 

  800.                 {
    801. 

  801.                     BOOL bDontStop = FALSE;
    802. 

  802.                     switch (cToken)
    803. 

  803.                     {
    804. 

  804.                         case '/':                       // AM/PM, A/P
    805. 

  805.                         {
    806. 

  806.                             sal_Unicode cNext = rStr.GetChar(nPos);
    807. 

  807.                             if ( cNext == 'P' || cNext == 'p' )
    808. 

  808.                             {
    809. 

  809.                                 xub_StrLen nLen = sSymbol.Len();
    810. 

  810.                                 if ( 1 <= nLen
    811. 

  811.                                         && (sSymbol.GetChar(0) == 'A' || sSymbol.GetChar(0) == 'a')
    812. 

  812.                                         && (nLen == 1 || (nLen == 2
    813. 

  813.                                             && (sSymbol.GetChar(1) == 'M' || sSymbol.GetChar(1) == 'm')
    814. 

  814.                                             && (rStr.GetChar(nPos+1) == 'M' || rStr.GetChar(nPos+1) == 'm'))) )
    815. 

  815.                                 {
    816. 

  816.                                     sSymbol += cToken;
    817. 

  817.                                     bDontStop = TRUE;
    818. 

  818.                                 }
    819. 

  819.                             }
    820. 

  820.                         }
    821. 

  821.                         break;
    822. 

  822.                     }
    823. 

  823.                     // anything not recognized will stop the scan
    824. 

  824.                     if ( eState != SsStop && !bDontStop )
    825. 

  825.                     {
    826. 

  826.                         eState = SsStop;
    827. 

  827.                         nPos--;
    828. 

  828.                         eType = NF_SYMBOLTYPE_STRING;
    829. 

  829.                     }
    830. 

  830.                 }
    831. 

  831.             }
    832. 

  832.             break;
    833. 

  833.             case SsGetStar:
    834. 

  834.             {
    835. 

  835.                 eState = SsStop;
    836. 

  836.                 sSymbol += cToken;
    837. 

  837.                 nRepPos = (nPos - nStart) - 1;  // everytime > 0!!
    838. 

  838.             }
    839. 

  839.             break;
    840. 

  840.             case SsGetBlank:
    841. 

  841.             {
    842. 

  842.                 eState = SsStop;
    843. 

  843.                 sSymbol += cToken;
    844. 

  844.             }
    845. 

  845.             break;
    846. 

  846.             default:
    847. 

  847.             break;
    848. 

  848.         }                                   // of switch
    849. 

  849.     }                                       // of while
    850. 

  850.     if (eState == SsGetWord)
    851. 

  851.         eType = NF_SYMBOLTYPE_STRING;
    852. 

  852.     return eType;
    853. 

  853. }
    854. 

  854. 

  855. xub_StrLen ImpSvNumberformatScan::Symbol_Division(const String& rString)
    856. 

  856. {
    857. 

  857.     nCurrPos = STRING_NOTFOUND;
    858. 

  858.                                                     // Ist Waehrung im Spiel?
    859. 

  859.     String sString = pFormatter->GetCharClass()->uppercase(rString);
    860. 

  860.     xub_StrLen nCPos = 0;
    861. 

  861.     while (nCPos != STRING_NOTFOUND)
    862. 

  862.     {
    863. 

  863.         nCPos = sString.Search(GetCurString(),nCPos);
    864. 

  864.         if (nCPos != STRING_NOTFOUND)
    865. 

  865.         {
    866. 

  866.             // in Quotes?
    867. 

  867.             xub_StrLen nQ = SvNumberformat::GetQuoteEnd( sString, nCPos );
    868. 

  868.             if ( nQ == STRING_NOTFOUND )
    869. 

  869.             {
    870. 

  870.                 sal_Unicode c;
    871. 

  871.                 if ( nCPos == 0 ||
    872. 

  872.                     ((c = sString.GetChar(xub_StrLen(nCPos-1))) != '"'
    873. 

  873.                             && c != '\\') )         // dm kann durch "dm
    874. 

  874.                 {                                   // \d geschuetzt werden
    875. 

  875.                     nCurrPos = nCPos;
    876. 

  876.                     nCPos = STRING_NOTFOUND;        // Abbruch
    877. 

  877.                 }
    878. 

  878.                 else
    879. 

  879.                     nCPos++;                        // weitersuchen
    880. 

  880.             }
    881. 

  881.             else
    882. 

  882.                 nCPos = nQ + 1;                     // weitersuchen
    883. 

  883.         }
    884. 

  884.     }
    885. 

  885.     nAnzStrings = 0;
    886. 

  886.     BOOL bStar = FALSE;                 // wird bei '*'Detektion gesetzt
    887. 

  887.     Reset();
    888. 

  888. 

  889.     xub_StrLen nPos = 0;
    890. 

  890.     const xub_StrLen nLen = rString.Len();
    891. 

  891.     while (nPos < nLen && nAnzStrings < NF_MAX_FORMAT_SYMBOLS)
    892. 

  892.     {
    893. 

  893.         nTypeArray[nAnzStrings] = Next_Symbol(rString, nPos, sStrArray[nAnzStrings]);
    894. 

  894.         if (nTypeArray[nAnzStrings] == NF_SYMBOLTYPE_STAR)
    895. 

  895.         {                               // Ueberwachung des '*'
    896. 

  896.             if (bStar)
    897. 

  897.                 return nPos;        // Fehler: doppelter '*'
    898. 

  898.             else
    899. 

  899.                 bStar = TRUE;
    900. 

  900.         }
    901. 

  901.         nAnzStrings++;
    902. 

  902.     }
    903. 

  903. 

  904.     return 0;                       // 0 => ok
    905. 

  905. }
    906. 

  906. 

  907. void ImpSvNumberformatScan::SkipStrings(USHORT& i, xub_StrLen& nPos)
    908. 

  908. {
    909. 

  909.     while (i < nAnzStrings && (   nTypeArray[i] == NF_SYMBOLTYPE_STRING
    910. 

  910.                                || nTypeArray[i] == NF_SYMBOLTYPE_BLANK
    911. 

  911.                                || nTypeArray[i] == NF_SYMBOLTYPE_STAR) )
    912. 

  912.     {
    913. 

  913.         nPos = nPos + sStrArray[i].Len();
    914. 

  914.         i++;
    915. 

  915.     }
    916. 

  916. }
    917. 

  917. 

  918. 

  919. USHORT ImpSvNumberformatScan::PreviousKeyword(USHORT i)
    920. 

  920. {
    921. 

  921.     short res = 0;
    922. 

  922.     if (i > 0 && i < nAnzStrings)
    923. 

  923.     {
    924. 

  924.         i--;
    925. 

  925.         while (i > 0 && nTypeArray[i] <= 0)
    926. 

  926.             i--;
    927. 

  927.         if (nTypeArray[i] > 0)
    928. 

  928.             res = nTypeArray[i];
    929. 

  929.     }
    930. 

  930.     return res;
    931. 

  931. }
    932. 

  932. 

  933. USHORT ImpSvNumberformatScan::NextKeyword(USHORT i)
    934. 

  934. {
    935. 

  935.     short res = 0;
    936. 

  936.     if (i < nAnzStrings-1)
    937. 

  937.     {
    938. 

  938.         i++;
    939. 

  939.         while (i < nAnzStrings-1 && nTypeArray[i] <= 0)
    940. 

  940.             i++;
    941. 

  941.         if (nTypeArray[i] > 0)
    942. 

  942.             res = nTypeArray[i];
    943. 

  943.     }
    944. 

  944.     return res;
    945. 

  945. }
    946. 

  946. 

  947. short ImpSvNumberformatScan::PreviousType( USHORT i )
    948. 

  948. {
    949. 

  949.     if ( i > 0 && i < nAnzStrings )
    950. 

  950.     {
    951. 

  951.         do
    952. 

  952.         {
    953. 

  953.             i--;
    954. 

  954.         } while ( i > 0 && nTypeArray[i] == NF_SYMBOLTYPE_EMPTY );
    955. 

  955.         return nTypeArray[i];
    956. 

  956.     }
    957. 

  957.     return 0;
    958. 

  958. }
    959. 

  959. 

  960. sal_Unicode ImpSvNumberformatScan::PreviousChar(USHORT i)
    961. 

  961. {
    962. 

  962.     sal_Unicode res = ' ';
    963. 

  963.     if (i > 0 && i < nAnzStrings)
    964. 

  964.     {
    965. 

  965.         i--;
    966. 

  966.         while (i > 0 && (   nTypeArray[i] == NF_SYMBOLTYPE_EMPTY
    967. 

  967.                          || nTypeArray[i] == NF_SYMBOLTYPE_STRING
    968. 

  968.                          || nTypeArray[i] == NF_SYMBOLTYPE_STAR
    969. 

  969.                          || nTypeArray[i] == NF_SYMBOLTYPE_BLANK ) )
    970. 

  970.             i--;
    971. 

  971.         if (sStrArray[i].Len() > 0)
    972. 

  972.             res = sStrArray[i].GetChar(xub_StrLen(sStrArray[i].Len()-1));
    973. 

  973.     }
    974. 

  974.     return res;
    975. 

  975. }
    976. 

  976. 

  977. sal_Unicode ImpSvNumberformatScan::NextChar(USHORT i)
    978. 

  978. {
    979. 

  979.     sal_Unicode res = ' ';
    980. 

  980.     if (i < nAnzStrings-1)
    981. 

  981.     {
    982. 

  982.         i++;
    983. 

  983.         while (i < nAnzStrings-1 &&
    984. 

  984.                (   nTypeArray[i] == NF_SYMBOLTYPE_EMPTY
    985. 

  985.                 || nTypeArray[i] == NF_SYMBOLTYPE_STRING
    986. 

  986.                 || nTypeArray[i] == NF_SYMBOLTYPE_STAR
    987. 

  987.                 || nTypeArray[i] == NF_SYMBOLTYPE_BLANK))
    988. 

  988.             i++;
    989. 

  989.         if (sStrArray[i].Len() > 0)
    990. 

  990.             res = sStrArray[i].GetChar(0);
    991. 

  991.     }
    992. 

  992.     return res;
    993. 

  993. }
    994. 

  994. 

  995. BOOL ImpSvNumberformatScan::IsLastBlankBeforeFrac(USHORT i)
    996. 

  996. {
    997. 

  997.     BOOL res = TRUE;
    998. 

  998.     if (i < nAnzStrings-1)
    999. 

  999.     {
    1000. 

  1000.         BOOL bStop = FALSE;
    1001. 

  1001.         i++;
    1002. 

  1002.         while (i < nAnzStrings-1 && !bStop)
    1003. 

  1003.         {
    1004. 

  1004.             i++;
    1005. 

  1005.             if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
    1006. 

  1006.                     sStrArray[i].GetChar(0) == '/')
    1007. 

  1007.                 bStop = TRUE;
    1008. 

  1008.             else if ( nTypeArray[i] == NF_SYMBOLTYPE_DEL &&
    1009. 

  1009.                     sStrArray[i].GetChar(0) == ' ')
    1010. 

  1010.                 res = FALSE;
    1011. 

  1011.         }
    1012. 

  1012.         if (!bStop)                                 // kein '/'
    1013. 

  1013.             res = FALSE;
    1014. 

  1014.     }
    1015. 

  1015.     else
    1016. 

  1016.         res = FALSE;                                // kein '/' mehr
    1017. 

  1017. 

  1018.     return res;
    1019. 

  1019. }
    1020. 

  1020. 

  1021. void ImpSvNumberformatScan::Reset()
    1022. 

  1022. {
    1023. 

  1023.     nAnzStrings = 0;
    1024. 

  1024.     nAnzResStrings = 0;
    1025. 

  1025.     eScannedType = NUMBERFORMAT_UNDEFINED;
    1026. 

  1026.     nRepPos = 0;
    1027. 

  1027.     bExp = FALSE;
    1028. 

  1028.     bThousand = FALSE;
    1029. 

  1029.     nThousand = 0;
    1030. 

  1030.     bDecSep = FALSE;
    1031. 

  1031.     nDecPos =  -1;
    1032. 

  1032.     nExpPos = (USHORT) -1;
    1033. 

  1033.     nBlankPos = (USHORT) -1;
    1034. 

  1034.     nCntPre = 0;
    1035. 

  1035.     nCntPost = 0;
    1036. 

  1036.     nCntExp = 0;
    1037. 

  1037.     bFrac = FALSE;
    1038. 

  1038.     bBlank = FALSE;
    1039. 

  1039.     nNatNumModifier = 0;
    1040. 

  1040. }
    1041. 

  1041. 

  1042. 

  1043. BOOL ImpSvNumberformatScan::Is100SecZero( USHORT i, BOOL bHadDecSep )
    1044. 

  1044. {
    1045. 

  1045.     USHORT nIndexPre = PreviousKeyword( i );
    1046. 

  1046.     return (nIndexPre == NF_KEY_S || nIndexPre == NF_KEY_SS)
    1047. 

  1047.             && (bHadDecSep                 // S, SS ','
    1048. 

  1048.             || (i>0 && nTypeArray[i-1] == NF_SYMBOLTYPE_STRING));
    1049. 

  1049.                 // SS"any"00  take "any" as a valid decimal separator
    1050. 

  1050. }
    1051. 

  1051. 

  1052. 

  1053. xub_StrLen ImpSvNumberformatScan::ScanType(const String&)
    1054. 

  1054. {
    1055. 

  1055.     const LocaleDataWrapper* pLoc = pFormatter->GetLocaleData();
    1056. 

  1056. 

  1057.     xub_StrLen nPos = 0;
    1058. 

  1058.     USHORT i = 0;
    1059. 

  1059.     short eNewType;
    1060. 

  1060.     BOOL bMatchBracket = FALSE;
    1061. 

  1061. 

  1062.     SkipStrings(i, nPos);
    1063. 

  1063.     while (i < nAnzStrings)
    1064. 

  1064.     {
    1065. 

  1065.         if (nTypeArray[i] > 0)
    1066. 

  1066.         {                                       // keyword
    1067. 

  1067.             switch (nTypeArray[i])
    1068. 

  1068.             {
    1069. 

  1069.                 case NF_KEY_E:                          // E
    1070. 

  1070.                     eNewType = NUMBERFORMAT_SCIENTIFIC;
    1071. 

  1071.                 break;
    1072. 

  1072.                 case NF_KEY_AMPM:                       // AM,A,PM,P
    1073. 

  1073.                 case NF_KEY_AP:
    1074. 

  1074.                 case NF_KEY_H:                          // H
    1075. 

  1075.                 case NF_KEY_HH:                         // HH
    1076. 

  1076.                 case NF_KEY_S:                          // S
    1077. 

  1077.                 case NF_KEY_SS:                         // SS
    1078. 

  1078.                     eNewType = NUMBERFORMAT_TIME;
    1079. 

  1079.                 break;
    1080. 

  1080.                 case NF_KEY_M:                          // M
    1081. 

  1081.                 case NF_KEY_MM:                         // MM
    1082. 

  1082.                 {                                       // minute or month
    1083. 

  1083.                     USHORT nIndexPre = PreviousKeyword(i);
    1084. 

  1084.                     USHORT nIndexNex = NextKeyword(i);
    1085. 

  1085.                     sal_Unicode cChar = PreviousChar(i);
    1086. 

  1086.                     if (nIndexPre == NF_KEY_H   ||  // H
    1087. 

  1087.                         nIndexPre == NF_KEY_HH  ||  // HH
    1088. 

  1088.                         nIndexNex == NF_KEY_S   ||  // S
    1089. 

  1089.                         nIndexNex == NF_KEY_SS  ||  // SS
    1090. 

  1090.                         cChar == '['  )     // [M
    1091. 

  1091.                     {
    1092. 

  1092.                         eNewType = NUMBERFORMAT_TIME;
    1093. 

  1093.                         nTypeArray[i] -= 2;         // 6 -> 4, 7 -> 5
    1094. 

  1094.                     }
    1095. 

  1095.                     else
    1096. 

  1096.                         eNewType = NUMBERFORMAT_DATE;
    1097. 

  1097.                 }
    1098. 

  1098.                 break;
    1099. 

  1099.                 case NF_KEY_MMM:                // MMM
    1100. 

  1100.                 case NF_KEY_MMMM:               // MMMM
    1101. 

  1101.                 case NF_KEY_MMMMM:              // MMMMM
    1102. 

  1102.                 case NF_KEY_Q:                  // Q
    1103. 

  1103.                 case NF_KEY_QQ:                 // QQ
    1104. 

  1104.                 case NF_KEY_D:                  // D
    1105. 

  1105.                 case NF_KEY_DD:                 // DD
    1106. 

  1106.                 case NF_KEY_DDD:                // DDD
    1107. 

  1107.                 case NF_KEY_DDDD:               // DDDD
    1108. 

  1108.                 case NF_KEY_YY:                 // YY
    1109. 

  1109.                 case NF_KEY_YYYY:               // YYYY
    1110. 

  1110.                 case NF_KEY_NN:                 // NN
    1111. 

  1111.                 case NF_KEY_NNN:                // NNN
    1112. 

  1112.                 case NF_KEY_NNNN:               // NNNN
    1113. 

  1113.                 case NF_KEY_WW :                // WW
    1114. 

  1114.                 case NF_KEY_AAA :               // AAA
    1115. 

  1115.                 case NF_KEY_AAAA :              // AAAA
    1116. 

  1116.                 case NF_KEY_EC :                // E
    1117. 

  1117.                 case NF_KEY_EEC :               // EE
    1118. 

  1118.                 case NF_KEY_G :                 // G
    1119. 

  1119.                 case NF_KEY_GG :                // GG
    1120. 

  1120.                 case NF_KEY_GGG :               // GGG
    1121. 

  1121.                 case NF_KEY_R :                 // R
    1122. 

  1122.                 case NF_KEY_RR :                // RR
    1123. 

  1123.                     eNewType = NUMBERFORMAT_DATE;
    1124. 

  1124.                 break;
    1125. 

  1125.                 case NF_KEY_CCC:                // CCC
    1126. 

  1126.                     eNewType = NUMBERFORMAT_CURRENCY;
    1127. 

  1127.                 break;
    1128. 

  1128.                 case NF_KEY_GENERAL:            // Standard
    1129. 

  1129.                     eNewType = NUMBERFORMAT_NUMBER;
    1130. 

  1130.                 break;
    1131. 

  1131.                 default:
    1132. 

  1132.                     eNewType = NUMBERFORMAT_UNDEFINED;
    1133. 

  1133.                 break;
    1134. 

  1134.             }
    1135. 

  1135.         }
    1136. 

  1136.         else
    1137. 

  1137.         {                                       // control character
    1138. 

  1138.             switch ( sStrArray[i].GetChar(0) )
    1139. 

  1139.             {
    1140. 

  1140.                 case '#':
    1141. 

  1141.                 case '?':
    1142. 

  1142.                     eNewType = NUMBERFORMAT_NUMBER;
    1143. 

  1143.                 break;
    1144. 

  1144.                 case '0':
    1145. 

  1145.                 {
    1146. 

  1146.                     if ( (eScannedType & NUMBERFORMAT_TIME) == NUMBERFORMAT_TIME )
    1147. 

  1147.                     {
    1148. 

  1148.                         if ( Is100SecZero( i, bDecSep ) )
    1149. 

  1149.                         {
    1150. 

  1150.                             bDecSep = TRUE;                 // subsequent 0's
    1151. 

  1151.                             eNewType = NUMBERFORMAT_TIME;
    1152. 

  1152.                         }
    1153. 

  1153.                         else
    1154. 

  1154.                             return nPos;                    // Error
    1155. 

  1155.                     }
    1156. 

  1156.                     else
    1157. 

  1157.                         eNewType = NUMBERFORMAT_NUMBER;
    1158. 

  1158.                 }
    1159. 

  1159.                 break;
    1160. 

  1160.                 case '%':
    1161. 

  1161.                     eNewType = NUMBERFORMAT_PERCENT;
    1162. 

  1162.                 break;
    1163. 

  1163.                 case '/':
    1164. 

  1164.                     eNewType = NUMBERFORMAT_FRACTION;
    1165. 

  1165.                 break;
    1166. 

  1166.                 case '[':
    1167. 

  1167.                 {
    1168. 

  1168.                     if ( i < nAnzStrings-1 &&
    1169. 

  1169.                             nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
    1170. 

  1170.                             sStrArray[i+1].GetChar(0) == '$' )
    1171. 

  1171.                     {   // as of SV_NUMBERFORMATTER_VERSION_NEW_CURR
    1172. 

  1172.                         eNewType = NUMBERFORMAT_CURRENCY;
    1173. 

  1173.                         bMatchBracket = TRUE;
    1174. 

  1174.                     }
    1175. 

  1175.                     else if ( i < nAnzStrings-1 &&
    1176. 

  1176.                             nTypeArray[i+1] == NF_SYMBOLTYPE_STRING &&
    1177. 

  1177.                             sStrArray[i+1].GetChar(0) == '~' )
    1178. 

  1178.                     {   // as of SV_NUMBERFORMATTER_VERSION_CALENDAR
    1179. 

  1179.                         eNewType = NUMBERFORMAT_DATE;
    1180. 

  1180.                         bMatchBracket = TRUE;
    1181. 

  1181.                     }
    1182. 

  1182.                     else
    1183. 

  1183.                     {
    1184. 

  1184.                         USHORT nIndexNex = NextKeyword(i);
    1185. 

  1185.                         if (nIndexNex == NF_KEY_H   ||  // H
    1186. 

  1186.     …
    1187.

Large files files are truncated, but you can click here to view the full file