git.oblomov.eu Git - wine/blob - ole/ole2nls.c

   1 /*
   2  *      OLE2NLS library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  *      Copyright 1998  David Lee Lambert
   6  *      Copyright 2000  Julio César Gázquez
   7  */
   8
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include <ctype.h>
  12 #include <stdlib.h>
  13 #include <locale.h>
  14 #include "windef.h"
  15 #include "wingdi.h"
  16 #include "winuser.h"
  17 #include "heap.h"
  18 #include "options.h"
  19 #include "winver.h"
  20 #include "winnls.h"
  21 #include "winreg.h"
  22 #include "winerror.h"
  23 #include "debugtools.h"
  24 #include "crtdll.h"
  25 #include "main.h"
  26
  27 DEFAULT_DEBUG_CHANNEL(ole);
  28 DECLARE_DEBUG_CHANNEL(string);
  29 DECLARE_DEBUG_CHANNEL(win32);
  30
  31 struct NLS_langlocale {
  32         const int lang;
  33         struct NLS_localevar {
  34                 const int       type;
  35                 const char      *val;
  36         } locvars[120];
  37 };
  38
  39 static LPVOID lpNLSInfo = NULL;
  40
  41 #define LANG_BEGIN(l,s) {       MAKELANGID(l,s), {
  42
  43 #define LOCVAL(type,value)                                      {type,value},
  44
  45 #define LANG_END                                         }},
  46
  47 static const struct NLS_langlocale langlocales[] = {
  48 /* add languages in numerical order of main language (last two digits)
  49  * it is much easier to find the missing holes that way */
  50
  51 LANG_BEGIN (LANG_CATALAN, SUBLANG_DEFAULT)      /*0x0403*/
  52 #include "nls/cat.nls"
  53 LANG_END
  54
  55 LANG_BEGIN (LANG_CZECH, SUBLANG_DEFAULT)        /*0x0405*/
  56 #include "nls/cze.nls"
  57 LANG_END
  58
  59 LANG_BEGIN (LANG_DANISH, SUBLANG_DEFAULT)       /*0x0406*/
  60 #include "nls/dan.nls"
  61 LANG_END
  62
  63 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN)                /*0x0407*/
  64 #include "nls/deu.nls"
  65 LANG_END
  66 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_SWISS)          /*0x0807*/
  67 #include "nls/des.nls"
  68 LANG_END
  69 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_AUSTRIAN)       /*0x0C07*/
  70 #include "nls/dea.nls"
  71 LANG_END
  72 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_LUXEMBOURG)     /*0x1007*/
  73 #include "nls/del.nls"
  74 LANG_END
  75 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_LIECHTENSTEIN)  /*0x1407*/
  76 #include "nls/dec.nls"
  77 LANG_END
  78
  79 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_US)           /*0x0409*/
  80 #include "nls/enu.nls"
  81 LANG_END
  82 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_UK)           /*0x0809*/
  83 #include "nls/eng.nls"
  84 LANG_END
  85 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_AUS)          /*0x0C09*/
  86 #include "nls/ena.nls"
  87 LANG_END
  88 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_CAN)          /*0x1009*/
  89 #include "nls/enc.nls"
  90 LANG_END
  91 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_NZ)           /*0x1409*/
  92 #include "nls/enz.nls"
  93 LANG_END
  94 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_EIRE)         /*0x1809*/
  95 #include "nls/eni.nls"
  96 LANG_END
  97 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_SAFRICA)      /*0x1C09*/
  98 #include "nls/ens.nls"
  99 LANG_END
 100 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_JAMAICA)      /*0x2009*/
 101 #include "nls/enj.nls"
 102 LANG_END
 103 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_CARRIBEAN)    /*0x2409*/
 104 #include "nls/enb.nls"
 105 LANG_END
 106 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_BELIZE)       /*0x2809*/
 107 #include "nls/enl.nls"
 108 LANG_END
 109 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_TRINIDAD)     /*0x2C09*/
 110 #include "nls/ent.nls"
 111 LANG_END
 112
 113 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH)              /*0x040a*/
 114 #include "nls/esp.nls"
 115 LANG_END
 116 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_MEXICAN)      /*0x080a*/
 117 #include "nls/esm.nls"
 118 LANG_END
 119 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_MODERN)       /*0x0C0a*/
 120 #include "nls/esn.nls"
 121 LANG_END
 122 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_GUATEMALA)    /*0x100a*/
 123 #include "nls/esg.nls"
 124 LANG_END
 125 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_COSTARICA)    /*0x140a*/
 126 #include "nls/esc.nls"
 127 LANG_END
 128 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PANAMA)       /*0x180a*/
 129 #include "nls/esa.nls"
 130 LANG_END
 131 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_DOMINICAN)    /*0x1C0A*/
 132 #include "nls/esd.nls"
 133 LANG_END
 134 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_VENEZUELA)    /*0x200a*/
 135 #include "nls/esv.nls"
 136 LANG_END
 137 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_COLOMBIA)     /*0x240a*/
 138 #include "nls/eso.nls"
 139 LANG_END
 140 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PERU)         /*0x280a*/
 141 #include "nls/esr.nls"
 142 LANG_END
 143 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_ARGENTINA)    /*0x2c0a*/
 144 #include "nls/ess.nls"
 145 LANG_END
 146 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_ECUADOR)      /*0x300a*/
 147 #include "nls/esf.nls"
 148 LANG_END
 149 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_CHILE)        /*0x340a*/
 150 #include "nls/esl.nls"
 151 LANG_END
 152 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_URUGUAY)      /*0x380a*/
 153 #include "nls/esy.nls"
 154 LANG_END
 155 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PARAGUAY)     /*0x3c0a*/
 156 #include "nls/esz.nls"
 157 LANG_END
 158 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_BOLIVIA)      /*0x400a*/
 159 #include "nls/esb.nls"
 160 LANG_END
 161 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_EL_SALVADOR)  /*0x440a*/
 162 #include "nls/ese.nls"
 163 LANG_END
 164 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_HONDURAS)     /*0x480a*/
 165 #include "nls/esh.nls"
 166 LANG_END
 167 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_NICARAGUA)    /*0x4c0a*/
 168 #include "nls/esi.nls"
 169 LANG_END
 170 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PUERTO_RICO)  /*0x500a*/
 171 #include "nls/esu.nls"
 172 LANG_END
 173
 174 LANG_BEGIN (LANG_FINNISH, SUBLANG_DEFAULT)      /*0x040B*/
 175 #include "nls/fin.nls"
 176 LANG_END
 177
 178 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH)                /*0x040C*/
 179 #include "nls/fra.nls"
 180 LANG_END
 181 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_BELGIAN)        /*0x080C*/
 182 #include "nls/frb.nls"
 183 LANG_END
 184 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_CANADIAN)       /*0x0C0C*/
 185 #include "nls/frc.nls"
 186 LANG_END
 187 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_SWISS)          /*0x100C*/
 188 #include "nls/frs.nls"
 189 LANG_END
 190 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_LUXEMBOURG)     /*0x140C*/
 191 #include "nls/frl.nls"
 192 LANG_END
 193
 194 LANG_BEGIN (LANG_HUNGARIAN, SUBLANG_DEFAULT)    /*0x040e*/
 195 #include "nls/hun.nls"
 196 LANG_END
 197
 198 LANG_BEGIN (LANG_ITALIAN, SUBLANG_ITALIAN)              /*0x0410*/
 199 #include "nls/ita.nls"
 200 LANG_END
 201 LANG_BEGIN (LANG_ITALIAN, SUBLANG_ITALIAN_SWISS)        /*0x0810*/
 202 #include "nls/its.nls"
 203 LANG_END
 204
 205 LANG_BEGIN (LANG_JAPANESE, SUBLANG_DEFAULT)     /*0x0411*/
 206 #include "nls/jpn.nls"
 207 LANG_END
 208
 209 LANG_BEGIN (LANG_KOREAN, SUBLANG_KOREAN)        /*0x0412*/
 210 #include "nls/kor.nls"
 211 LANG_END
 212
 213 LANG_BEGIN (LANG_DUTCH, SUBLANG_DUTCH)          /*0x0413*/
 214 #include "nls/nld.nls"
 215 LANG_END
 216 LANG_BEGIN (LANG_DUTCH, SUBLANG_DUTCH_BELGIAN)  /*0x0813*/
 217 #include "nls/nlb.nls"
 218 LANG_END
 219 LANG_BEGIN (LANG_DUTCH, SUBLANG_DUTCH_SURINAM)  /*0x0C13*/
 220 #include "nls/nls.nls"
 221 LANG_END
 222
 223 LANG_BEGIN (LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL)   /*0x0414*/
 224 #include "nls/nor.nls"
 225 LANG_END
 226 LANG_BEGIN (LANG_NORWEGIAN, SUBLANG_NORWEGIAN_NYNORSK)  /*0x0814*/
 227 #include "nls/non.nls"
 228 LANG_END
 229
 230 LANG_BEGIN (LANG_POLISH, SUBLANG_DEFAULT)       /*0x0415*/
 231 #include "nls/plk.nls"
 232 LANG_END
 233
 234 LANG_BEGIN (LANG_PORTUGUESE ,SUBLANG_PORTUGUESE_BRAZILIAN)      /*0x0416*/
 235 #include "nls/ptb.nls"
 236 LANG_END
 237 LANG_BEGIN (LANG_PORTUGUESE ,SUBLANG_PORTUGUESE)                /*0x0816*/
 238 #include "nls/ptg.nls"
 239 LANG_END
 240
 241 LANG_BEGIN (LANG_RUSSIAN, SUBLANG_DEFAULT)      /*0x419*/
 242 #include "nls/rus.nls"
 243 LANG_END
 244
 245 LANG_BEGIN (LANG_SLOVAK, SUBLANG_DEFAULT)       /*0x041b*/
 246 #include "nls/sky.nls"
 247 LANG_END
 248
 249 LANG_BEGIN (LANG_SWEDISH, SUBLANG_SWEDISH)              /*0x041d*/
 250 #include "nls/sve.nls"
 251 LANG_END
 252 LANG_BEGIN (LANG_SWEDISH, SUBLANG_SWEDISH_FINLAND)      /*0x081d*/
 253 #include "nls/svf.nls"
 254 LANG_END
 255
 256 LANG_BEGIN (LANG_THAI, SUBLANG_DEFAULT) /*0x41e*/
 257 #include "nls/tha.nls"
 258 LANG_END
 259 LANG_BEGIN (LANG_GAELIC, SUBLANG_DEFAULT) /* 0x043c */
 260 #include "nls/gae.nls"
 261 LANG_END
 262
 263 LANG_BEGIN (LANG_GAELIC, SUBLANG_GAELIC_SCOTTISH)
 264 #include "nls/gdh.nls"
 265 LANG_END
 266
 267 LANG_BEGIN (LANG_GAELIC, SUBLANG_GAELIC_MANX)
 268 #include "nls/gdv.nls"
 269 LANG_END
 270
 271 LANG_BEGIN (LANG_ESPERANTO, SUBLANG_DEFAULT)    /*0x048f*/
 272 #include "nls/esperanto.nls"
 273 LANG_END
 274
 275 LANG_BEGIN (LANG_WALON, SUBLANG_DEFAULT)        /*0x0490*/
 276 #include "nls/wal.nls"
 277 LANG_END
 278
 279 LANG_BEGIN (LANG_CORNISH, SUBLANG_DEFAULT) /* 0x0491  */
 280 #include "nls/cor.nls"
 281 LANG_END
 282
 283 LANG_BEGIN (LANG_WELSH, SUBLANG_DEFAULT) /* 0x0492 */
 284 #include "nls/cym.nls"
 285 LANG_END
 286
 287 LANG_BEGIN (LANG_BRETON, SUBLANG_DEFAULT) /* 0x0x93  */
 288 #include "nls/brf.nls"
 289 LANG_END
 290
 291             };
 292
 293
 294 /* Locale name to id map. used by EnumSystemLocales, GetLocaleInfoA
 295  * MUST contain all #defines from winnls.h
 296  * last entry has NULL name, 0 id.
 297  */
 298 #define LOCALE_ENTRY(x) {#x,LOCALE_##x}
 299 static const struct tagLOCALE_NAME2ID {
 300     const char  *name;
 301         DWORD   id;
 302 } locale_name2id[]= {
 303         LOCALE_ENTRY(ILANGUAGE),
 304         LOCALE_ENTRY(SLANGUAGE),
 305         LOCALE_ENTRY(SENGLANGUAGE),
 306         LOCALE_ENTRY(SABBREVLANGNAME),
 307         LOCALE_ENTRY(SNATIVELANGNAME),
 308         LOCALE_ENTRY(ICOUNTRY),
 309         LOCALE_ENTRY(SCOUNTRY),
 310         LOCALE_ENTRY(SENGCOUNTRY),
 311         LOCALE_ENTRY(SABBREVCTRYNAME),
 312         LOCALE_ENTRY(SNATIVECTRYNAME),
 313         LOCALE_ENTRY(IDEFAULTLANGUAGE),
 314         LOCALE_ENTRY(IDEFAULTCOUNTRY),
 315         LOCALE_ENTRY(IDEFAULTCODEPAGE),
 316         LOCALE_ENTRY(IDEFAULTANSICODEPAGE),
 317         LOCALE_ENTRY(IDEFAULTMACCODEPAGE),
 318         LOCALE_ENTRY(SLIST),
 319         LOCALE_ENTRY(IMEASURE),
 320         LOCALE_ENTRY(SDECIMAL),
 321         LOCALE_ENTRY(STHOUSAND),
 322         LOCALE_ENTRY(SGROUPING),
 323         LOCALE_ENTRY(IDIGITS),
 324         LOCALE_ENTRY(ILZERO),
 325         LOCALE_ENTRY(INEGNUMBER),
 326         LOCALE_ENTRY(SNATIVEDIGITS),
 327         LOCALE_ENTRY(SCURRENCY),
 328         LOCALE_ENTRY(SINTLSYMBOL),
 329         LOCALE_ENTRY(SMONDECIMALSEP),
 330         LOCALE_ENTRY(SMONTHOUSANDSEP),
 331         LOCALE_ENTRY(SMONGROUPING),
 332         LOCALE_ENTRY(ICURRDIGITS),
 333         LOCALE_ENTRY(IINTLCURRDIGITS),
 334         LOCALE_ENTRY(ICURRENCY),
 335         LOCALE_ENTRY(INEGCURR),
 336         LOCALE_ENTRY(SDATE),
 337         LOCALE_ENTRY(STIME),
 338         LOCALE_ENTRY(SSHORTDATE),
 339         LOCALE_ENTRY(SLONGDATE),
 340         LOCALE_ENTRY(STIMEFORMAT),
 341         LOCALE_ENTRY(IDATE),
 342         LOCALE_ENTRY(ILDATE),
 343         LOCALE_ENTRY(ITIME),
 344         LOCALE_ENTRY(ITIMEMARKPOSN),
 345         LOCALE_ENTRY(ICENTURY),
 346         LOCALE_ENTRY(ITLZERO),
 347         LOCALE_ENTRY(IDAYLZERO),
 348         LOCALE_ENTRY(IMONLZERO),
 349         LOCALE_ENTRY(S1159),
 350         LOCALE_ENTRY(S2359),
 351         LOCALE_ENTRY(ICALENDARTYPE),
 352         LOCALE_ENTRY(IOPTIONALCALENDAR),
 353         LOCALE_ENTRY(IFIRSTDAYOFWEEK),
 354         LOCALE_ENTRY(IFIRSTWEEKOFYEAR),
 355         LOCALE_ENTRY(SDAYNAME1),
 356         LOCALE_ENTRY(SDAYNAME2),
 357         LOCALE_ENTRY(SDAYNAME3),
 358         LOCALE_ENTRY(SDAYNAME4),
 359         LOCALE_ENTRY(SDAYNAME5),
 360         LOCALE_ENTRY(SDAYNAME6),
 361         LOCALE_ENTRY(SDAYNAME7),
 362         LOCALE_ENTRY(SABBREVDAYNAME1),
 363         LOCALE_ENTRY(SABBREVDAYNAME2),
 364         LOCALE_ENTRY(SABBREVDAYNAME3),
 365         LOCALE_ENTRY(SABBREVDAYNAME4),
 366         LOCALE_ENTRY(SABBREVDAYNAME5),
 367         LOCALE_ENTRY(SABBREVDAYNAME6),
 368         LOCALE_ENTRY(SABBREVDAYNAME7),
 369         LOCALE_ENTRY(SMONTHNAME1),
 370         LOCALE_ENTRY(SMONTHNAME2),
 371         LOCALE_ENTRY(SMONTHNAME3),
 372         LOCALE_ENTRY(SMONTHNAME4),
 373         LOCALE_ENTRY(SMONTHNAME5),
 374         LOCALE_ENTRY(SMONTHNAME6),
 375         LOCALE_ENTRY(SMONTHNAME7),
 376         LOCALE_ENTRY(SMONTHNAME8),
 377         LOCALE_ENTRY(SMONTHNAME9),
 378         LOCALE_ENTRY(SMONTHNAME10),
 379         LOCALE_ENTRY(SMONTHNAME11),
 380         LOCALE_ENTRY(SMONTHNAME12),
 381         LOCALE_ENTRY(SMONTHNAME13),
 382         LOCALE_ENTRY(SABBREVMONTHNAME1),
 383         LOCALE_ENTRY(SABBREVMONTHNAME2),
 384         LOCALE_ENTRY(SABBREVMONTHNAME3),
 385         LOCALE_ENTRY(SABBREVMONTHNAME4),
 386         LOCALE_ENTRY(SABBREVMONTHNAME5),
 387         LOCALE_ENTRY(SABBREVMONTHNAME6),
 388         LOCALE_ENTRY(SABBREVMONTHNAME7),
 389         LOCALE_ENTRY(SABBREVMONTHNAME8),
 390         LOCALE_ENTRY(SABBREVMONTHNAME9),
 391         LOCALE_ENTRY(SABBREVMONTHNAME10),
 392         LOCALE_ENTRY(SABBREVMONTHNAME11),
 393         LOCALE_ENTRY(SABBREVMONTHNAME12),
 394         LOCALE_ENTRY(SABBREVMONTHNAME13),
 395         LOCALE_ENTRY(SPOSITIVESIGN),
 396         LOCALE_ENTRY(SNEGATIVESIGN),
 397         LOCALE_ENTRY(IPOSSIGNPOSN),
 398         LOCALE_ENTRY(INEGSIGNPOSN),
 399         LOCALE_ENTRY(IPOSSYMPRECEDES),
 400         LOCALE_ENTRY(IPOSSEPBYSPACE),
 401         LOCALE_ENTRY(INEGSYMPRECEDES),
 402         LOCALE_ENTRY(INEGSEPBYSPACE),
 403         LOCALE_ENTRY(FONTSIGNATURE),
 404         LOCALE_ENTRY(SISO639LANGNAME),
 405         LOCALE_ENTRY(SISO3166CTRYNAME),
 406         {NULL,0},
 407 };
 408
 409 const struct map_lcid2str {
 410         LCID            langid;
 411         const char      *langname;
 412 } languages[]={
 413         {0x0401,"Arabic (Saudi Arabia)"},
 414         {0x0801,"Arabic (Iraq)"},
 415         {0x0c01,"Arabic (Egypt)"},
 416         {0x1001,"Arabic (Libya)"},
 417         {0x1401,"Arabic (Algeria)"},
 418         {0x1801,"Arabic (Morocco)"},
 419         {0x1c01,"Arabic (Tunisia)"},
 420         {0x2001,"Arabic (Oman)"},
 421         {0x2401,"Arabic (Yemen)"},
 422         {0x2801,"Arabic (Syria)"},
 423         {0x2c01,"Arabic (Jordan)"},
 424         {0x3001,"Arabic (Lebanon)"},
 425         {0x3401,"Arabic (Kuwait)"},
 426         {0x3801,"Arabic (United Arab Emirates)"},
 427         {0x3c01,"Arabic (Bahrain)"},
 428         {0x4001,"Arabic (Qatar)"},
 429         {0x0402,"Bulgarian"},
 430         {0x0403,"Catalan"},
 431         {0x0404,"Chinese (Taiwan)"},
 432         {0x0804,"Chinese (People's Republic of China)"},
 433         {0x0c04,"Chinese (Hong Kong)"},
 434         {0x1004,"Chinese (Singapore)"},
 435         {0x1404,"Chinese (Macau)"},
 436         {0x0405,"Czech"},
 437         {0x0406,"Danish"},
 438         {0x0407,"German (Germany)"},
 439         {0x0807,"German (Switzerland)"},
 440         {0x0c07,"German (Austria)"},
 441         {0x1007,"German (Luxembourg)"},
 442         {0x1407,"German (Liechtenstein)"},
 443         {0x0408,"Greek"},
 444         {0x0409,"English (United States)"},
 445         {0x0809,"English (United Kingdom)"},
 446         {0x0c09,"English (Australian)"},
 447         {0x1009,"English (Canadian)"},
 448         {0x1409,"English (New Zealand)"},
 449         {0x1809,"English (Ireland)"},
 450         {0x1c09,"English (South Africa)"},
 451         {0x2009,"English (Jamaica)"},
 452         {0x2409,"English (Caribbean)"},
 453         {0x2809,"English (Belize)"},
 454         {0x2c09,"English (Trinidad & Tobago)"},
 455         {0x3009,"English (Zimbabwe)"},
 456         {0x3409,"English (Philippines)"},
 457         {0x040a,"Spanish (Spain, traditional sorting)"},
 458         {0x080a,"Spanish (Mexico)"},
 459         {0x0c0a,"Spanish (Spain, international sorting)"},
 460         {0x100a,"Spanish (Guatemala)"},
 461         {0x140a,"Spanish (Costa Rica)"},
 462         {0x180a,"Spanish (Panama)"},
 463         {0x1c0a,"Spanish (Dominican Republic)"},
 464         {0x200a,"Spanish (Venezuela)"},
 465         {0x240a,"Spanish (Colombia)"},
 466         {0x280a,"Spanish (Peru)"},
 467         {0x2c0a,"Spanish (Argentina)"},
 468         {0x300a,"Spanish (Ecuador)"},
 469         {0x340a,"Spanish (Chile)"},
 470         {0x380a,"Spanish (Uruguay)"},
 471         {0x3c0a,"Spanish (Paraguay)"},
 472         {0x400a,"Spanish (Bolivia)"},
 473         {0x440a,"Spanish (El Salvador)"},
 474         {0x480a,"Spanish (Honduras)"},
 475         {0x4c0a,"Spanish (Nicaragua)"},
 476         {0x500a,"Spanish (Puerto Rico)"},
 477         {0x040b,"Finnish"},
 478         {0x040c,"French (France)"},
 479         {0x080c,"French (Belgium)"},
 480         {0x0c0c,"French (Canada)"},
 481         {0x100c,"French (Switzerland)"},
 482         {0x140c,"French (Luxembourg)"},
 483         {0x180c,"French (Monaco)"},
 484         {0x040d,"Hebrew"},
 485         {0x040e,"Hungarian"},
 486         {0x040f,"Icelandic"},
 487         {0x0410,"Italian (Italy)"},
 488         {0x0810,"Italian (Switzerland)"},
 489         {0x0411,"Japanese"},
 490         {0x0412,"Korean (Wansung)"},
 491         {0x0812,"Korean (Johab)"},
 492         {0x0413,"Dutch (Netherlands)"},
 493         {0x0813,"Dutch (Belgium)"},
 494         {0x0414,"Norwegian (Bokmal)"},
 495         {0x0814,"Norwegian (Nynorsk)"},
 496         {0x0415,"Polish"},
 497         {0x0416,"Portuguese (Brazil)"},
 498         {0x0816,"Portuguese (Portugal)"},
 499         {0x0417,"Rhaeto Romanic"},
 500         {0x0418,"Romanian"},
 501         {0x0818,"Moldavian"},
 502         {0x0419,"Russian (Russia)"},
 503         {0x0819,"Russian (Moldavia)"},
 504         {0x041a,"Croatian"},
 505         {0x081a,"Serbian (latin)"},
 506         {0x0c1a,"Serbian (cyrillic)"},
 507         {0x041b,"Slovak"},
 508         {0x041c,"Albanian"},
 509         {0x041d,"Swedish (Sweden)"},
 510         {0x081d,"Swedish (Finland)"},
 511         {0x041e,"Thai"},
 512         {0x041f,"Turkish"},
 513         {0x0420,"Urdu"},
 514         {0x0421,"Indonesian"},
 515         {0x0422,"Ukrainian"},
 516         {0x0423,"Belarusian"},
 517         {0x0424,"Slovene"},
 518         {0x0425,"Estonian"},
 519         {0x0426,"Latvian"},
 520         {0x0427,"Lithuanian (modern)"},
 521         {0x0827,"Lithuanian (classic)"},
 522         {0x0428,"Maori"},
 523         {0x0429,"Farsi"},
 524         {0x042a,"Vietnamese"},
 525         {0x042b,"Armenian"},
 526         {0x042c,"Azeri (latin)"},
 527         {0x082c,"Azeri (cyrillic)"},
 528         {0x042d,"Basque"},
 529         {0x042e,"Sorbian"},
 530         {0x042f,"Macedonian"},
 531         {0x0430,"Sutu"},
 532         {0x0431,"Tsonga"},
 533         {0x0432,"Tswana"},
 534         {0x0433,"Venda"},
 535         {0x0434,"Xhosa"},
 536         {0x0435,"Zulu"},
 537         {0x0436,"Afrikaans"},
 538         {0x0437,"Georgian"},
 539         {0x0438,"Faeroese"},
 540         {0x0439,"Hindi"},
 541         {0x043a,"Maltese"},
 542         {0x043b,"Saami"},
 543         {0x043c,"Irish gaelic"},
 544         {0x083c,"Scottish gaelic"},
 545         {0x0c3c,"Manx Gaelic"},
 546         {0x043e,"Malay (Malaysia)"},
 547         {0x083e,"Malay (Brunei Darussalam)"},
 548         {0x043f,"Kazak"},
 549         {0x0441,"Swahili"},
 550         {0x0443,"Uzbek (latin)"},
 551         {0x0843,"Uzbek (cyrillic)"},
 552         {0x0444,"Tatar"},
 553         {0x0445,"Bengali"},
 554         {0x0446,"Punjabi"},
 555         {0x0447,"Gujarati"},
 556         {0x0448,"Oriya"},
 557         {0x0449,"Tamil"},
 558         {0x044a,"Telugu"},
 559         {0x044b,"Kannada"},
 560         {0x044c,"Malayalam"},
 561         {0x044d,"Assamese"},
 562         {0x044e,"Marathi"},
 563         {0x044f,"Sanskrit"},
 564         {0x0457,"Konkani"},
 565         {0x048f,"Esperanto"}, /* Non official */
 566         {0x0490,"Walon"}, /* Non official */
 567         {0x0491,"Cornish"},     /* Not official */
 568         {0x0492,"Welsh"},       /* Not official */
 569         {0x0493,"Breton"},      /* Not official */
 570         {0x0000,"Unknown"}
 571     }, languages_de[]={
 572         {0x0401,"Arabic"},
 573         {0x0402,"Bulgarisch"},
 574         {0x0403,"Katalanisch"},
 575         {0x0404,"Traditionales Chinesisch"},
 576         {0x0405,"Tschecisch"},
 577         {0x0406,"Dänisch"},
 578         {0x0407,"Deutsch"},
 579         {0x0408,"Griechisch"},
 580         {0x0409,"Amerikanisches Englisch"},
 581         {0x040A,"Kastilisches Spanisch"},
 582         {0x040B,"Finnisch"},
 583         {0x040C,"Franzvsisch"},
 584         {0x040D,"Hebrdisch"},
 585         {0x040E,"Ungarisch"},
 586         {0x040F,"Isldndisch"},
 587         {0x0410,"Italienisch"},
 588         {0x0411,"Japanisch"},
 589         {0x0412,"Koreanisch"},
 590         {0x0413,"Niederldndisch"},
 591         {0x0414,"Norwegisch-Bokmal"},
 592         {0x0415,"Polnisch"},
 593         {0x0416,"Brasilianisches Portugiesisch"},
 594         {0x0417,"Rdtoromanisch"},
 595         {0x0418,"Rumdnisch"},
 596         {0x0419,"Russisch"},
 597         {0x041A,"Kroatoserbisch (lateinisch)"},
 598         {0x041B,"Slowenisch"},
 599         {0x041C,"Albanisch"},
 600         {0x041D,"Schwedisch"},
 601         {0x041E,"Thai"},
 602         {0x041F,"Türkisch"},
 603         {0x0420,"Urdu"},
 604         {0x0421,"Bahasa"},
 605         {0x0804,"Vereinfachtes Chinesisch"},
 606         {0x0807,"Schweizerdeutsch"},
 607         {0x0809,"Britisches Englisch"},
 608         {0x080A,"Mexikanisches Spanisch"},
 609         {0x080C,"Belgisches Franzvsisch"},
 610         {0x0810,"Schweizerisches Italienisch"},
 611         {0x0813,"Belgisches Niederldndisch"},
 612         {0x0814,"Norgwegisch-Nynorsk"},
 613         {0x0816,"Portugiesisch"},
 614         {0x081A,"Serbokratisch (kyrillisch)"},
 615         {0x0C1C,"Kanadisches Franzvsisch"},
 616         {0x100C,"Schweizerisches Franzvsisch"},
 617         {0x0000,"Unbekannt"},
 618 };
 619
 620 /***********************************************************************
 621  *           GetUserDefaultLCID       (OLE2NLS.1)
 622  */
 623 LCID WINAPI GetUserDefaultLCID()
 624 {
 625         return MAKELCID( GetUserDefaultLangID() , SORT_DEFAULT );
 626 }
 627
 628 /***********************************************************************
 629  *         GetSystemDefaultLCID       (OLE2NLS.2)
 630  */
 631 LCID WINAPI GetSystemDefaultLCID()
 632 {
 633         return GetUserDefaultLCID();
 634 }
 635
 636 /***********************************************************************
 637  *         GetUserDefaultLangID       (OLE2NLS.3)
 638  */
 639 LANGID WINAPI GetUserDefaultLangID()
 640 {
 641         /* caching result, if defined from environment, which should (?) not change during a WINE session */
 642         static  LANGID  userLCID = 0;
 643         if (Options.language) {
 644                 return Languages[Options.language].langid;
 645         }
 646
 647         if (userLCID == 0) {
 648                 char *buf=NULL;
 649                 char *lang,*country,*charset,*dialect,*next;
 650                 int     ret=0;
 651
 652                 buf=getenv("LANGUAGE");
 653                 if (!buf) buf=getenv("LANG");
 654                 if (!buf) buf=getenv("LC_ALL");
 655                 if (!buf) buf=getenv("LC_MESSAGES");
 656                 if (!buf) buf=getenv("LC_CTYPE");
 657                 if (!buf) return userLCID = MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT );
 658
 659                 if (!strcmp(buf,"POSIX") || !strcmp(buf,"C")) {
 660                         return MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT );
 661                 }
 662
 663                 lang=buf;
 664
 665                 do {
 666                         next=strchr(lang,':'); if (next) *next++='\0';
 667                         dialect=strchr(lang,'@'); if (dialect) *dialect++='\0';
 668                         charset=strchr(lang,'.'); if (charset) *charset++='\0';
 669                         country=strchr(lang,'_'); if (country) *country++='\0';
 670
 671                         ret=MAIN_GetLanguageID(lang, country, charset, dialect);
 672
 673                         lang=next;
 674
 675                 } while (lang && !ret);
 676
 677                 /* FIXME : are strings returned by getenv() to be free()'ed ? */
 678                 userLCID = (LANGID)ret;
 679         }
 680         return userLCID;
 681 }
 682
 683 /***********************************************************************
 684  *         GetSystemDefaultLangID     (OLE2NLS.4)
 685  */
 686 LANGID WINAPI GetSystemDefaultLangID()
 687 {
 688         return GetUserDefaultLangID();
 689 }
 690
 691 /******************************************************************************
 692  *              GetLocaleInfo16 [OLE2NLS.5]
 693  * Is the last parameter really WORD for Win16?
 694  */
 695 INT16 WINAPI GetLocaleInfo16(LCID lcid,LCTYPE LCType,LPSTR buf,INT16 len)
 696 {
 697         return GetLocaleInfoA(lcid,LCType,buf,len);
 698 }
 699 /******************************************************************************
 700  * ConvertDefaultLocale32 [KERNEL32.147]
 701  */
 702 LCID WINAPI ConvertDefaultLocale32 (LCID lcid)
 703 {       switch (lcid)
 704         {  case LOCALE_SYSTEM_DEFAULT:
 705              return GetSystemDefaultLCID();
 706            case LOCALE_USER_DEFAULT:
 707              return GetUserDefaultLCID();
 708            case 0:
 709              return MAKELCID (LANG_NEUTRAL, SUBLANG_NEUTRAL);
 710         }
 711         return MAKELANGID( PRIMARYLANGID(lcid), SUBLANG_NEUTRAL);
 712 }
 713 /******************************************************************************
 714  * GetLocaleInfoA [KERNEL32.342]
 715  *
 716  * NOTES
 717  *  LANG_NEUTRAL is equal to LOCALE_SYSTEM_DEFAULT
 718  *
 719  *  MS online documentation states that the string returned is NULL terminated
 720  *  except for LOCALE_FONTSIGNATURE  which "will return a non-NULL
 721  *  terminated string".
 722  */
 723 INT WINAPI GetLocaleInfoA(LCID lcid,LCTYPE LCType,LPSTR buf,INT len)
 724 {
 725   LPCSTR  retString;
 726         int     found,i;
 727         int     lang=0;
 728
 729   TRACE("(lcid=0x%lx,lctype=0x%lx,%p,%x)\n",lcid,LCType,buf,len);
 730
 731   if (len && (! buf) ) {
 732     SetLastError(ERROR_INSUFFICIENT_BUFFER);
 733                 return 0;
 734         }
 735
 736         if (lcid ==0 || lcid == LANG_SYSTEM_DEFAULT || (LCType & LOCALE_NOUSEROVERRIDE) )       /* 0x00, 0x400 */
 737         {
 738             lcid = GetSystemDefaultLCID();
 739         }
 740         else if (lcid == LANG_USER_DEFAULT) /*0x800*/
 741         {
 742             lcid = GetUserDefaultLCID();
 743         }
 744         LCType &= ~(LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP);
 745
 746         /* As an option, we could obtain the value from win.ini.
 747            This would not match the Wine compile-time option.
 748            Also, not all identifiers are available from win.ini */
 749         retString=0;
 750         /* If we are through all of this, retLen should not be zero anymore.
 751            If it is, the value is not supported */
 752         i=0;
 753         while (locale_name2id[i].name!=NULL) {
 754                 if (LCType == locale_name2id[i].id) {
 755                         retString = locale_name2id[i].name;
 756                         break;
 757                 }
 758                 i++;
 759         }
 760         if (!retString) {
 761       FIXME("Unkown LC type %lX\n",LCType);
 762                 return 0;
 763         }
 764
 765     found=0;lang=lcid;
 766     for (i=0;(i<3 && !found);i++) {
 767       int j;
 768
 769       for (j=0;j<sizeof(langlocales)/sizeof(langlocales[0]);j++) {
 770         if (langlocales[j].lang == lang) {
 771           int k;
 772
 773           for (k=0;k<sizeof(langlocales[j].locvars)/sizeof(langlocales[j].locvars[0]) && (langlocales[j].locvars[k].type);k++) {
 774             if (langlocales[j].locvars[k].type == LCType) {
 775               found = 1;
 776               retString = langlocales[j].locvars[k].val;
 777           break;
 778             }
 779           }
 780           if (found)
 781             break;
 782         }
 783       }
 784           /* language not found, try without a sublanguage*/
 785           if (i==1) lang=MAKELANGID( PRIMARYLANGID(lang), SUBLANG_DEFAULT);
 786           /* mask the LC Value */
 787           if (i==2) LCType &= 0xfff;
 788     }
 789
 790     if(!found) {
 791       ERR("'%s' not supported for your language (%04X).\n",
 792                         retString,(WORD)lcid);
 793                 SetLastError(ERROR_INVALID_PARAMETER);
 794                 return 0;
 795         }
 796     /* a FONTSIGNATURE is not a string, just 6 DWORDs  */
 797     if (LCType == LOCALE_FONTSIGNATURE) {
 798         if (len)
 799             memcpy(buf, retString, (len<=sizeof(FONTSIGNATURE))?len:sizeof(FONTSIGNATURE));
 800         return sizeof(FONTSIGNATURE);
 801     }
 802     /* if len=0 return only the length, don't touch the buffer*/
 803     if (len) lstrcpynA(buf,retString,len);
 804     return strlen(retString)+1;
 805 }
 806
 807 /******************************************************************************
 808  *              GetLocaleInfoW  [KERNEL32.343]
 809  *
 810  * NOTES
 811  *  MS documentation states that len "specifies the size, in bytes (ANSI version)
 812  *  or characters (Unicode version), of" wbuf. Thus the number returned is
 813  *  the same between GetLocaleInfoW and GetLocaleInfoA.
 814  */
 815 INT WINAPI GetLocaleInfoW(LCID lcid,LCTYPE LCType,LPWSTR wbuf,INT len)
 816 {       WORD wlen;
 817         LPSTR abuf;
 818
 819         if (len && (! wbuf) )
 820         { SetLastError(ERROR_INSUFFICIENT_BUFFER);
 821           return 0;
 822         }
 823
 824         abuf = (LPSTR)HeapAlloc(GetProcessHeap(),0,len);
 825         wlen = GetLocaleInfoA(lcid, LCType, abuf, len);
 826
 827         if (wlen && len)        /* if len=0 return only the length*/
 828           lstrcpynAtoW(wbuf,abuf,len);
 829
 830         HeapFree(GetProcessHeap(),0,abuf);
 831         return wlen;
 832 }
 833
 834 /******************************************************************************
 835  *              SetLocaleInfoA  [KERNEL32.656]
 836  */
 837 BOOL16 WINAPI SetLocaleInfoA(DWORD lcid, DWORD lctype, LPCSTR data)
 838 {
 839     FIXME("(%ld,%ld,%s): stub\n",lcid,lctype,data);
 840     return TRUE;
 841 }
 842
 843 /******************************************************************************
 844  *              IsValidLocale   [KERNEL32.489]
 845  */
 846 BOOL WINAPI IsValidLocale(LCID lcid,DWORD flags)
 847 {
 848         /* we support ANY language. Well, at least say that...*/
 849         return TRUE;
 850 }
 851
 852 /******************************************************************************
 853  *              EnumSystemLocalesW      [KERNEL32.209]
 854  */
 855 BOOL WINAPI EnumSystemLocalesW( LOCALE_ENUMPROCW lpfnLocaleEnum,
 856                                     DWORD flags )
 857 {
 858         int     i;
 859         BOOL    ret;
 860         WCHAR   buffer[200];
 861         HKEY    xhkey;
 862
 863         TRACE_(win32)("(%p,%08lx)\n",lpfnLocaleEnum,flags );
 864         /* see if we can reuse the Win95 registry entries.... */
 865         if (ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,"System\\CurrentControlSet\\control\\Nls\\Locale\\",&xhkey)) {
 866                 i=0;
 867                 while (1) {
 868                         if (ERROR_SUCCESS!=RegEnumKeyW(xhkey,i,buffer,sizeof(buffer)))
 869                                 break;
 870                         if (!lpfnLocaleEnum(buffer))
 871                                 break;
 872                         i++;
 873                 }
 874                 RegCloseKey(xhkey);
 875                 return TRUE;
 876         }
 877
 878         i=0;
 879         while (languages[i].langid!=0)
 880         {
 881             LPWSTR cp;
 882             char   xbuffer[10];
 883
 884             sprintf(xbuffer,"%08lx",(DWORD)languages[i].langid);
 885
 886             cp = HEAP_strdupAtoW( GetProcessHeap(), 0, xbuffer );
 887             ret = lpfnLocaleEnum(cp);
 888             HeapFree( GetProcessHeap(), 0, cp );
 889             if (!ret) break;
 890             i++;
 891         }
 892         return TRUE;
 893 }
 894
 895 /******************************************************************************
 896  *              EnumSystemLocalesA      [KERNEL32.208]
 897  */
 898 BOOL WINAPI EnumSystemLocalesA(LOCALE_ENUMPROCA lpfnLocaleEnum,
 899                                    DWORD flags)
 900 {
 901         int     i;
 902         CHAR    buffer[200];
 903         HKEY    xhkey;
 904
 905         TRACE_(win32)("(%p,%08lx)\n",
 906                 lpfnLocaleEnum,flags
 907         );
 908
 909         if ( ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,
 910                     "System\\CurrentControlSet\\Control\\Nls\\Locale\\",
 911                     &xhkey)) {
 912             i=0;
 913             while (1) {
 914                 DWORD size=sizeof(buffer);
 915                 if (ERROR_SUCCESS!=RegEnumValueA(xhkey,i,buffer,&size,NULL,
 916                             NULL, NULL,NULL))
 917                     break;
 918                 if (size && !lpfnLocaleEnum(buffer))
 919                     break;
 920                 i++;
 921             }
 922             RegCloseKey(xhkey);
 923             return TRUE;
 924         }
 925         i=0;
 926         while (languages[i].langid!=0) {
 927                 sprintf(buffer,"%08lx",(DWORD)languages[i].langid);
 928                 if (!lpfnLocaleEnum(buffer))
 929                         break;
 930                 i++;
 931         }
 932         return TRUE;
 933 }
 934
 935 static const unsigned char CT_CType2_LUT[] = {
 936   C2_NOTAPPLICABLE, /*   -   0 */
 937   C2_NOTAPPLICABLE, /*   -   1 */
 938   C2_NOTAPPLICABLE, /*   -   2 */
 939   C2_NOTAPPLICABLE, /*   -   3 */
 940   C2_NOTAPPLICABLE, /*   -   4 */
 941   C2_NOTAPPLICABLE, /*   -   5 */
 942   C2_NOTAPPLICABLE, /*   -   6 */
 943   C2_NOTAPPLICABLE, /*   -   7 */
 944   C2_NOTAPPLICABLE, /*   -   8 */
 945   C2_SEGMENTSEPARATOR, /*   -   9 */
 946   C2_NOTAPPLICABLE, /*   -  10 */
 947   C2_NOTAPPLICABLE, /*   -  11 */
 948   C2_NOTAPPLICABLE, /*   -  12 */
 949   C2_NOTAPPLICABLE, /*   -  13 */
 950   C2_NOTAPPLICABLE, /*   -  14 */
 951   C2_NOTAPPLICABLE, /*   -  15 */
 952   C2_NOTAPPLICABLE, /*   -  16 */
 953   C2_NOTAPPLICABLE, /*   -  17 */
 954   C2_NOTAPPLICABLE, /*   -  18 */
 955   C2_NOTAPPLICABLE, /*   -  19 */
 956   C2_NOTAPPLICABLE, /*   -  20 */
 957   C2_NOTAPPLICABLE, /*   -  21 */
 958   C2_NOTAPPLICABLE, /*   -  22 */
 959   C2_NOTAPPLICABLE, /*   -  23 */
 960   C2_NOTAPPLICABLE, /*   -  24 */
 961   C2_NOTAPPLICABLE, /*   -  25 */
 962   C2_NOTAPPLICABLE, /*   -  26 */
 963   C2_NOTAPPLICABLE, /*   -  27 */
 964   C2_NOTAPPLICABLE, /*   -  28 */
 965   C2_NOTAPPLICABLE, /*   -  29 */
 966   C2_NOTAPPLICABLE, /*   -  30 */
 967   C2_NOTAPPLICABLE, /*   -  31 */
 968   C2_WHITESPACE, /*   -  32 */
 969   C2_OTHERNEUTRAL, /* ! -  33 */
 970   C2_OTHERNEUTRAL, /* " -  34 */ /* " */
 971   C2_EUROPETERMINATOR, /* # -  35 */
 972   C2_EUROPETERMINATOR, /* $ -  36 */
 973   C2_EUROPETERMINATOR, /* % -  37 */
 974   C2_LEFTTORIGHT, /* & -  38 */
 975   C2_OTHERNEUTRAL, /* ' -  39 */
 976   C2_OTHERNEUTRAL, /* ( -  40 */
 977   C2_OTHERNEUTRAL, /* ) -  41 */
 978   C2_OTHERNEUTRAL, /* * -  42 */
 979   C2_EUROPETERMINATOR, /* + -  43 */
 980   C2_COMMONSEPARATOR, /* , -  44 */
 981   C2_EUROPETERMINATOR, /* - -  45 */
 982   C2_EUROPESEPARATOR, /* . -  46 */
 983   C2_EUROPESEPARATOR, /* / -  47 */
 984   C2_EUROPENUMBER, /* 0 -  48 */
 985   C2_EUROPENUMBER, /* 1 -  49 */
 986   C2_EUROPENUMBER, /* 2 -  50 */
 987   C2_EUROPENUMBER, /* 3 -  51 */
 988   C2_EUROPENUMBER, /* 4 -  52 */
 989   C2_EUROPENUMBER, /* 5 -  53 */
 990   C2_EUROPENUMBER, /* 6 -  54 */
 991   C2_EUROPENUMBER, /* 7 -  55 */
 992   C2_EUROPENUMBER, /* 8 -  56 */
 993   C2_EUROPENUMBER, /* 9 -  57 */
 994   C2_COMMONSEPARATOR, /* : -  58 */
 995   C2_OTHERNEUTRAL, /* ; -  59 */
 996   C2_OTHERNEUTRAL, /* < -  60 */
 997   C2_OTHERNEUTRAL, /* = -  61 */
 998   C2_OTHERNEUTRAL, /* > -  62 */
 999   C2_OTHERNEUTRAL, /* ? -  63 */
1000   C2_LEFTTORIGHT, /* @ -  64 */
1001   C2_LEFTTORIGHT, /* A -  65 */
1002   C2_LEFTTORIGHT, /* B -  66 */
1003   C2_LEFTTORIGHT, /* C -  67 */
1004   C2_LEFTTORIGHT, /* D -  68 */
1005   C2_LEFTTORIGHT, /* E -  69 */
1006   C2_LEFTTORIGHT, /* F -  70 */
1007   C2_LEFTTORIGHT, /* G -  71 */
1008   C2_LEFTTORIGHT, /* H -  72 */
1009   C2_LEFTTORIGHT, /* I -  73 */
1010   C2_LEFTTORIGHT, /* J -  74 */
1011   C2_LEFTTORIGHT, /* K -  75 */
1012   C2_LEFTTORIGHT, /* L -  76 */
1013   C2_LEFTTORIGHT, /* M -  77 */
1014   C2_LEFTTORIGHT, /* N -  78 */
1015   C2_LEFTTORIGHT, /* O -  79 */
1016   C2_LEFTTORIGHT, /* P -  80 */
1017   C2_LEFTTORIGHT, /* Q -  81 */
1018   C2_LEFTTORIGHT, /* R -  82 */
1019   C2_LEFTTORIGHT, /* S -  83 */
1020   C2_LEFTTORIGHT, /* T -  84 */
1021   C2_LEFTTORIGHT, /* U -  85 */
1022   C2_LEFTTORIGHT, /* V -  86 */
1023   C2_LEFTTORIGHT, /* W -  87 */
1024   C2_LEFTTORIGHT, /* X -  88 */
1025   C2_LEFTTORIGHT, /* Y -  89 */
1026   C2_LEFTTORIGHT, /* Z -  90 */
1027   C2_OTHERNEUTRAL, /* [ -  91 */
1028   C2_OTHERNEUTRAL, /* \ -  92 */
1029   C2_OTHERNEUTRAL, /* ] -  93 */
1030   C2_OTHERNEUTRAL, /* ^ -  94 */
1031   C2_OTHERNEUTRAL, /* _ -  95 */
1032   C2_OTHERNEUTRAL, /* ` -  96 */
1033   C2_LEFTTORIGHT, /* a -  97 */
1034   C2_LEFTTORIGHT, /* b -  98 */
1035   C2_LEFTTORIGHT, /* c -  99 */
1036   C2_LEFTTORIGHT, /* d - 100 */
1037   C2_LEFTTORIGHT, /* e - 101 */
1038   C2_LEFTTORIGHT, /* f - 102 */
1039   C2_LEFTTORIGHT, /* g - 103 */
1040   C2_LEFTTORIGHT, /* h - 104 */
1041   C2_LEFTTORIGHT, /* i - 105 */
1042   C2_LEFTTORIGHT, /* j - 106 */
1043   C2_LEFTTORIGHT, /* k - 107 */
1044   C2_LEFTTORIGHT, /* l - 108 */
1045   C2_LEFTTORIGHT, /* m - 109 */
1046   C2_LEFTTORIGHT, /* n - 110 */
1047   C2_LEFTTORIGHT, /* o - 111 */
1048   C2_LEFTTORIGHT, /* p - 112 */
1049   C2_LEFTTORIGHT, /* q - 113 */
1050   C2_LEFTTORIGHT, /* r - 114 */
1051   C2_LEFTTORIGHT, /* s - 115 */
1052   C2_LEFTTORIGHT, /* t - 116 */
1053   C2_LEFTTORIGHT, /* u - 117 */
1054   C2_LEFTTORIGHT, /* v - 118 */
1055   C2_LEFTTORIGHT, /* w - 119 */
1056   C2_LEFTTORIGHT, /* x - 120 */
1057   C2_LEFTTORIGHT, /* y - 121 */
1058   C2_LEFTTORIGHT, /* z - 122 */
1059   C2_OTHERNEUTRAL, /* { - 123 */
1060   C2_OTHERNEUTRAL, /* | - 124 */
1061   C2_OTHERNEUTRAL, /* } - 125 */
1062   C2_OTHERNEUTRAL, /* ~ - 126 */
1063   C2_NOTAPPLICABLE, /* \7f - 127 */
1064   C2_NOTAPPLICABLE, /* \80 - 128 */
1065   C2_NOTAPPLICABLE, /* \81 - 129 */
1066   C2_OTHERNEUTRAL, /* \82 - 130 */
1067   C2_LEFTTORIGHT, /* \83 - 131 */
1068   C2_OTHERNEUTRAL, /* \84 - 132 */
1069   C2_OTHERNEUTRAL, /* \85 - 133 */
1070   C2_OTHERNEUTRAL, /* \86 - 134 */
1071   C2_OTHERNEUTRAL, /* \87 - 135 */
1072   C2_LEFTTORIGHT, /* \88 - 136 */
1073   C2_EUROPETERMINATOR, /* \89 - 137 */
1074   C2_LEFTTORIGHT, /* \8a - 138 */
1075   C2_OTHERNEUTRAL, /* \8b - 139 */
1076   C2_LEFTTORIGHT, /* \8c - 140 */
1077   C2_NOTAPPLICABLE, /* \8d - 141 */
1078   C2_NOTAPPLICABLE, /* \8e - 142 */
1079   C2_NOTAPPLICABLE, /* \8f - 143 */
1080   C2_NOTAPPLICABLE, /* \90 - 144 */
1081   C2_OTHERNEUTRAL, /* \91 - 145 */
1082   C2_OTHERNEUTRAL, /* \92 - 146 */
1083   C2_OTHERNEUTRAL, /* \93 - 147 */
1084   C2_OTHERNEUTRAL, /* \94 - 148 */
1085   C2_OTHERNEUTRAL, /* \95 - 149 */
1086   C2_OTHERNEUTRAL, /* \96 - 150 */
1087   C2_OTHERNEUTRAL, /* \97 - 151 */
1088   C2_LEFTTORIGHT, /* \98 - 152 */
1089   C2_OTHERNEUTRAL, /* \99 - 153 */
1090   C2_LEFTTORIGHT, /* \9a - 154 */
1091   C2_OTHERNEUTRAL, /* \9b - 155 */
1092   C2_LEFTTORIGHT, /* \9c - 156 */
1093   C2_NOTAPPLICABLE, /* \9d - 157 */
1094   C2_NOTAPPLICABLE, /* \9e - 158 */
1095   C2_LEFTTORIGHT, /* \9f - 159 */
1096   C2_WHITESPACE, /*   - 160 */
1097   C2_OTHERNEUTRAL, /* ¡ - 161 */
1098   C2_EUROPETERMINATOR, /* ¢ - 162 */
1099   C2_EUROPETERMINATOR, /* £ - 163 */
1100   C2_EUROPETERMINATOR, /* ¤ - 164 */
1101   C2_EUROPETERMINATOR, /* ¥ - 165 */
1102   C2_OTHERNEUTRAL, /* ¦ - 166 */
1103   C2_OTHERNEUTRAL, /* § - 167 */
1104   C2_OTHERNEUTRAL, /* ¨ - 168 */
1105   C2_OTHERNEUTRAL, /* © - 169 */
1106   C2_OTHERNEUTRAL, /* ª - 170 */
1107   C2_OTHERNEUTRAL, /* « - 171 */
1108   C2_OTHERNEUTRAL, /* ¬ - 172 */
1109   C2_OTHERNEUTRAL, /*  - 173 */
1110   C2_OTHERNEUTRAL, /* ® - 174 */
1111   C2_OTHERNEUTRAL, /* ¯ - 175 */
1112   C2_EUROPETERMINATOR, /* ° - 176 */
1113   C2_EUROPETERMINATOR, /* ± - 177 */
1114   C2_EUROPENUMBER, /* ² - 178 */
1115   C2_EUROPENUMBER, /* ³ - 179 */
1116   C2_OTHERNEUTRAL, /* ´ - 180 */
1117   C2_OTHERNEUTRAL, /* µ - 181 */
1118   C2_OTHERNEUTRAL, /* ¶ - 182 */
1119   C2_OTHERNEUTRAL, /* · - 183 */
1120   C2_OTHERNEUTRAL, /* ¸ - 184 */
1121   C2_EUROPENUMBER, /* ¹ - 185 */
1122   C2_OTHERNEUTRAL, /* º - 186 */
1123   C2_OTHERNEUTRAL, /* » - 187 */
1124   C2_OTHERNEUTRAL, /* ¼ - 188 */
1125   C2_OTHERNEUTRAL, /* ½ - 189 */
1126   C2_OTHERNEUTRAL, /* ¾ - 190 */
1127   C2_OTHERNEUTRAL, /* ¿ - 191 */
1128   C2_LEFTTORIGHT, /* À - 192 */
1129   C2_LEFTTORIGHT, /* Á - 193 */
1130   C2_LEFTTORIGHT, /* Â - 194 */
1131   C2_LEFTTORIGHT, /* Ã - 195 */
1132   C2_LEFTTORIGHT, /* Ä - 196 */
1133   C2_LEFTTORIGHT, /* Å - 197 */
1134   C2_LEFTTORIGHT, /* Æ - 198 */
1135   C2_LEFTTORIGHT, /* Ç - 199 */
1136   C2_LEFTTORIGHT, /* È - 200 */
1137   C2_LEFTTORIGHT, /* É - 201 */
1138   C2_LEFTTORIGHT, /* Ê - 202 */
1139   C2_LEFTTORIGHT, /* Ë - 203 */
1140   C2_LEFTTORIGHT, /* Ì - 204 */
1141   C2_LEFTTORIGHT, /* Í - 205 */
1142   C2_LEFTTORIGHT, /* Î - 206 */
1143   C2_LEFTTORIGHT, /* Ï - 207 */
1144   C2_LEFTTORIGHT, /* Ð - 208 */
1145   C2_LEFTTORIGHT, /* Ñ - 209 */
1146   C2_LEFTTORIGHT, /* Ò - 210 */
1147   C2_LEFTTORIGHT, /* Ó - 211 */
1148   C2_LEFTTORIGHT, /* Ô - 212 */
1149   C2_LEFTTORIGHT, /* Õ - 213 */
1150   C2_LEFTTORIGHT, /* Ö - 214 */
1151   C2_OTHERNEUTRAL, /* × - 215 */
1152   C2_LEFTTORIGHT, /* Ø - 216 */
1153   C2_LEFTTORIGHT, /* Ù - 217 */
1154   C2_LEFTTORIGHT, /* Ú - 218 */
1155   C2_LEFTTORIGHT, /* Û - 219 */
1156   C2_LEFTTORIGHT, /* Ü - 220 */
1157   C2_LEFTTORIGHT, /* Ý - 221 */
1158   C2_LEFTTORIGHT, /* Þ - 222 */
1159   C2_LEFTTORIGHT, /* ß - 223 */
1160   C2_LEFTTORIGHT, /* à - 224 */
1161   C2_LEFTTORIGHT, /* á - 225 */
1162   C2_LEFTTORIGHT, /* â - 226 */
1163   C2_LEFTTORIGHT, /* ã - 227 */
1164   C2_LEFTTORIGHT, /* ä - 228 */
1165   C2_LEFTTORIGHT, /* å - 229 */
1166   C2_LEFTTORIGHT, /* æ - 230 */
1167   C2_LEFTTORIGHT, /* ç - 231 */
1168   C2_LEFTTORIGHT, /* è - 232 */
1169   C2_LEFTTORIGHT, /* é - 233 */
1170   C2_LEFTTORIGHT, /* ê - 234 */
1171   C2_LEFTTORIGHT, /* ë - 235 */
1172   C2_LEFTTORIGHT, /* ì - 236 */
1173   C2_LEFTTORIGHT, /* í - 237 */
1174   C2_LEFTTORIGHT, /* î - 238 */
1175   C2_LEFTTORIGHT, /* ï - 239 */
1176   C2_LEFTTORIGHT, /* ð - 240 */
1177   C2_LEFTTORIGHT, /* ñ - 241 */
1178   C2_LEFTTORIGHT, /* ò - 242 */
1179   C2_LEFTTORIGHT, /* ó - 243 */
1180   C2_LEFTTORIGHT, /* ô - 244 */
1181   C2_LEFTTORIGHT, /* õ - 245 */
1182   C2_LEFTTORIGHT, /* ö - 246 */
1183   C2_OTHERNEUTRAL, /* ÷ - 247 */
1184   C2_LEFTTORIGHT, /* ø - 248 */
1185   C2_LEFTTORIGHT, /* ù - 249 */
1186   C2_LEFTTORIGHT, /* ú - 250 */
1187   C2_LEFTTORIGHT, /* û - 251 */
1188   C2_LEFTTORIGHT, /* ü - 252 */
1189   C2_LEFTTORIGHT, /* ý - 253 */
1190   C2_LEFTTORIGHT, /* þ - 254 */
1191   C2_LEFTTORIGHT /* ÿ - 255 */
1192 };
1193
1194 const WORD OLE2NLS_CT_CType3_LUT[] = {
1195   0x0000, /*   -   0 */
1196   0x0000, /*   -   1 */
1197   0x0000, /*   -   2 */
1198   0x0000, /*   -   3 */
1199   0x0000, /*   -   4 */
1200   0x0000, /*   -   5 */
1201   0x0000, /*   -   6 */
1202   0x0000, /*   -   7 */
1203   0x0000, /*   -   8 */
1204   0x0008, /*   -   9 */
1205   0x0008, /*   -  10 */
1206   0x0008, /*   -  11 */
1207   0x0008, /*   -  12 */
1208   0x0008, /*   -  13 */
1209   0x0000, /*   -  14 */
1210   0x0000, /*   -  15 */
1211   0x0000, /*   -  16 */
1212   0x0000, /*   -  17 */
1213   0x0000, /*   -  18 */
1214   0x0000, /*   -  19 */
1215   0x0000, /*   -  20 */
1216   0x0000, /*   -  21 */
1217   0x0000, /*   -  22 */
1218   0x0000, /*   -  23 */
1219   0x0000, /*   -  24 */
1220   0x0000, /*   -  25 */
1221   0x0000, /*   -  26 */
1222   0x0000, /*   -  27 */
1223   0x0000, /*   -  28 */
1224   0x0000, /*   -  29 */
1225   0x0000, /*   -  30 */
1226   0x0000, /*   -  31 */
1227   0x0048, /*   -  32 */
1228   0x0048, /* ! -  33 */
1229   0x0448, /* " -  34 */ /* " */
1230   0x0048, /* # -  35 */
1231   0x0448, /* $ -  36 */
1232   0x0048, /* % -  37 */
1233   0x0048, /* & -  38 */
1234   0x0440, /* ' -  39 */
1235   0x0048, /* ( -  40 */
1236   0x0048, /* ) -  41 */
1237   0x0048, /* * -  42 */
1238   0x0048, /* + -  43 */
1239   0x0048, /* , -  44 */
1240   0x0440, /* - -  45 */
1241   0x0048, /* . -  46 */
1242   0x0448, /* / -  47 */
1243   0x0040, /* 0 -  48 */
1244   0x0040, /* 1 -  49 */
1245   0x0040, /* 2 -  50 */
1246   0x0040, /* 3 -  51 */
1247   0x0040, /* 4 -  52 */
1248   0x0040, /* 5 -  53 */
1249   0x0040, /* 6 -  54 */
1250   0x0040, /* 7 -  55 */
1251   0x0040, /* 8 -  56 */
1252   0x0040, /* 9 -  57 */
1253   0x0048, /* : -  58 */
1254   0x0048, /* ; -  59 */
1255   0x0048, /* < -  60 */
1256   0x0448, /* = -  61 */
1257   0x0048, /* > -  62 */
1258   0x0048, /* ? -  63 */
1259   0x0448, /* @ -  64 */
1260   0x8040, /* A -  65 */
1261   0x8040, /* B -  66 */
1262   0x8040, /* C -  67 */
1263   0x8040, /* D -  68 */
1264   0x8040, /* E -  69 */
1265   0x8040, /* F -  70 */
1266   0x8040, /* G -  71 */
1267   0x8040, /* H -  72 */
1268   0x8040, /* I -  73 */
1269   0x8040, /* J -  74 */
1270   0x8040, /* K -  75 */
1271   0x8040, /* L -  76 */
1272   0x8040, /* M -  77 */
1273   0x8040, /* N -  78 */
1274   0x8040, /* O -  79 */
1275   0x8040, /* P -  80 */
1276   0x8040, /* Q -  81 */
1277   0x8040, /* R -  82 */
1278   0x8040, /* S -  83 */
1279   0x8040, /* T -  84 */
1280   0x8040, /* U -  85 */
1281   0x8040, /* V -  86 */
1282   0x8040, /* W -  87 */
1283   0x8040, /* X -  88 */
1284   0x8040, /* Y -  89 */
1285   0x8040, /* Z -  90 */
1286   0x0048, /* [ -  91 */
1287   0x0448, /* \ -  92 */
1288   0x0048, /* ] -  93 */
1289   0x0448, /* ^ -  94 */
1290   0x0448, /* _ -  95 */
1291   0x0448, /* ` -  96 */
1292   0x8040, /* a -  97 */
1293   0x8040, /* b -  98 */
1294   0x8040, /* c -  99 */
1295   0x8040, /* d - 100 */
1296   0x8040, /* e - 101 */
1297   0x8040, /* f - 102 */
1298   0x8040, /* g - 103 */
1299   0x8040, /* h - 104 */
1300   0x8040, /* i - 105 */
1301   0x8040, /* j - 106 */
1302   0x8040, /* k - 107 */
1303   0x8040, /* l - 108 */
1304   0x8040, /* m - 109 */
1305   0x8040, /* n - 110 */
1306   0x8040, /* o - 111 */
1307   0x8040, /* p - 112 */
1308   0x8040, /* q - 113 */
1309   0x8040, /* r - 114 */
1310   0x8040, /* s - 115 */
1311   0x8040, /* t - 116 */
1312   0x8040, /* u - 117 */
1313   0x8040, /* v - 118 */
1314   0x8040, /* w - 119 */
1315   0x8040, /* x - 120 */
1316   0x8040, /* y - 121 */
1317   0x8040, /* z - 122 */
1318   0x0048, /* { - 123 */
1319   0x0048, /* | - 124 */
1320   0x0048, /* } - 125 */
1321   0x0448, /* ~ - 126 */
1322   0x0000, /* \7f - 127 */
1323   0x0000, /* \80 - 128 */
1324   0x0000, /* \81 - 129 */
1325   0x0008, /* \82 - 130 */
1326   0x8000, /* \83 - 131 */
1327   0x0008, /* \84 - 132 */
1328   0x0008, /* \85 - 133 */
1329   0x0008, /* \86 - 134 */
1330   0x0008, /* \87 - 135 */
1331   0x0001, /* \88 - 136 */
1332   0x0008, /* \89 - 137 */
1333   0x8003, /* \8a - 138 */
1334   0x0008, /* \8b - 139 */
1335   0x8000, /* \8c - 140 */
1336   0x0000, /* \8d - 141 */
1337   0x0000, /* \8e - 142 */
1338   0x0000, /* \8f - 143 */
1339   0x0000, /* \90 - 144 */
1340   0x0088, /* \91 - 145 */
1341   0x0088, /* \92 - 146 */
1342   0x0088, /* \93 - 147 */
1343   0x0088, /* \94 - 148 */
1344   0x0008, /* \95 - 149 */
1345   0x0400, /* \96 - 150 */
1346   0x0400, /* \97 - 151 */
1347   0x0408, /* \98 - 152 */
1348   0x0000, /* \99 - 153 */
1349   0x8003, /* \9a - 154 */
1350   0x0008, /* \9b - 155 */
1351   0x8000, /* \9c - 156 */
1352   0x0000, /* \9d - 157 */
1353   0x0000, /* \9e - 158 */
1354   0x8003, /* \9f - 159 */
1355   0x0008, /*   - 160 */
1356   0x0008, /* ¡ - 161 */
1357   0x0048, /* ¢ - 162 */
1358   0x0048, /* £ - 163 */
1359   0x0008, /* ¤ - 164 */
1360   0x0048, /* ¥ - 165 */
1361   0x0048, /* ¦ - 166 */
1362   0x0008, /* § - 167 */
1363   0x0408, /* ¨ - 168 */
1364   0x0008, /* © - 169 */
1365   0x0400, /* ª - 170 */
1366   0x0008, /* « - 171 */
1367   0x0048, /* ¬ - 172 */
1368   0x0408, /*  - 173 */
1369   0x0008, /* ® - 174 */
1370   0x0448, /* ¯ - 175 */
1371   0x0008, /* ° - 176 */
1372   0x0008, /* ± - 177 */
1373   0x0000, /* ² - 178 */
1374   0x0000, /* ³ - 179 */
1375   0x0408, /* ´ - 180 */
1376   0x0008, /* µ - 181 */
1377   0x0008, /* ¶ - 182 */
1378   0x0008, /* · - 183 */
1379   0x0408, /* ¸ - 184 */
1380   0x0000, /* ¹ - 185 */
1381   0x0400, /* º - 186 */
1382   0x0008, /* » - 187 */
1383   0x0000, /* ¼ - 188 */
1384   0x0000, /* ½ - 189 */
1385   0x0000, /* ¾ - 190 */
1386   0x0008, /* ¿ - 191 */
1387   0x8003, /* À - 192 */
1388   0x8003, /* Á - 193 */
1389   0x8003, /* Â - 194 */
1390   0x8003, /* Ã - 195 */
1391   0x8003, /* Ä - 196 */
1392   0x8003, /* Å - 197 */
1393   0x8000, /* Æ - 198 */
1394   0x8003, /* Ç - 199 */
1395   0x8003, /* È - 200 */
1396   0x8003, /* É - 201 */
1397   0x8003, /* Ê - 202 */
1398   0x8003, /* Ë - 203 */
1399   0x8003, /* Ì - 204 */
1400   0x8003, /* Í - 205 */
1401   0x8003, /* Î - 206 */
1402   0x8003, /* Ï - 207 */
1403   0x8000, /* Ð - 208 */
1404   0x8003, /* Ñ - 209 */
1405   0x8003, /* Ò - 210 */
1406   0x8003, /* Ó - 211 */
1407   0x8003, /* Ô - 212 */
1408   0x8003, /* Õ - 213 */
1409   0x8003, /* Ö - 214 */
1410   0x0008, /* × - 215 */
1411   0x8003, /* Ø - 216 */
1412   0x8003, /* Ù - 217 */
1413   0x8003, /* Ú - 218 */
1414   0x8003, /* Û - 219 */
1415   0x8003, /* Ü - 220 */
1416   0x8003, /* Ý - 221 */
1417   0x8000, /* Þ - 222 */
1418   0x8000, /* ß - 223 */
1419   0x8003, /* à - 224 */
1420   0x8003, /* á - 225 */
1421   0x8003, /* â - 226 */
1422   0x8003, /* ã - 227 */
1423   0x8003, /* ä - 228 */
1424   0x8003, /* å - 229 */
1425   0x8000, /* æ - 230 */
1426   0x8003, /* ç - 231 */
1427   0x8003, /* è - 232 */
1428   0x8003, /* é - 233 */
1429   0x8003, /* ê - 234 */
1430   0x8003, /* ë - 235 */
1431   0x8003, /* ì - 236 */
1432   0x8003, /* í - 237 */
1433   0x8003, /* î - 238 */
1434   0x8003, /* ï - 239 */
1435   0x8000, /* ð - 240 */
1436   0x8003, /* ñ - 241 */
1437   0x8003, /* ò - 242 */
1438   0x8003, /* ó - 243 */
1439   0x8003, /* ô - 244 */
1440   0x8003, /* õ - 245 */
1441   0x8003, /* ö - 246 */
1442   0x0008, /* ÷ - 247 */
1443   0x8003, /* ø - 248 */
1444   0x8003, /* ù - 249 */
1445   0x8003, /* ú - 250 */
1446   0x8003, /* û - 251 */
1447   0x8003, /* ü - 252 */
1448   0x8003, /* ý - 253 */
1449   0x8000, /* þ - 254 */
1450   0x8003  /* ÿ - 255 */
1451 };
1452
1453 /******************************************************************************
1454  *              GetStringType16 [OLE2NLS.7]
1455  */
1456 BOOL16 WINAPI GetStringType16(LCID locale,DWORD dwInfoType,LPCSTR src,
1457                               INT16 cchSrc,LPWORD chartype)
1458 {
1459         return GetStringTypeExA(locale,dwInfoType,src,cchSrc,chartype);
1460 }
1461 /******************************************************************************
1462  *              GetStringTypeA  [KERNEL32.396]
1463  */
1464 BOOL WINAPI GetStringTypeA(LCID locale,DWORD dwInfoType,LPCSTR src,
1465                                INT cchSrc,LPWORD chartype)
1466 {
1467         return GetStringTypeExA(locale,dwInfoType,src,cchSrc,chartype);
1468 }
1469
1470 /******************************************************************************
1471  *              GetStringTypeExA        [KERNEL32.397]
1472  *
1473  * FIXME: Ignores the locale.
1474  */
1475 BOOL WINAPI GetStringTypeExA(LCID locale,DWORD dwInfoType,LPCSTR src,
1476                                  INT cchSrc,LPWORD chartype)
1477 {
1478         int     i;
1479
1480         if ((src==NULL) || (chartype==NULL) || (src==(LPSTR)chartype))
1481         {
1482           SetLastError(ERROR_INVALID_PARAMETER);
1483           return FALSE;
1484         }
1485
1486         if (cchSrc==-1)
1487           cchSrc=lstrlenA(src)+1;
1488
1489         switch (dwInfoType) {
1490         case CT_CTYPE1:
1491           for (i=0;i<cchSrc;i++)
1492           {
1493             chartype[i] = 0;
1494             if (isdigit(src[i])) chartype[i]|=C1_DIGIT;
1495             if (isalpha(src[i])) chartype[i]|=C1_ALPHA;
1496             if (islower(src[i])) chartype[i]|=C1_LOWER;
1497             if (isupper(src[i])) chartype[i]|=C1_UPPER;
1498             if (isspace(src[i])) chartype[i]|=C1_SPACE;
1499             if (ispunct(src[i])) chartype[i]|=C1_PUNCT;
1500             if (iscntrl(src[i])) chartype[i]|=C1_CNTRL;
1501 /* FIXME: isblank() is a GNU extension */
1502 /*              if (isblank(src[i])) chartype[i]|=C1_BLANK; */
1503             if ((src[i] == ' ') || (src[i] == '\t')) chartype[i]|=C1_BLANK;
1504             /* C1_XDIGIT */
1505         }
1506         return TRUE;
1507
1508         case CT_CTYPE2:
1509           for (i=0;i<cchSrc;i++)
1510           {
1511             chartype[i]=(WORD)CT_CType2_LUT[i];
1512           }
1513           return TRUE;
1514
1515         case CT_CTYPE3:
1516           for (i=0;i<cchSrc;i++)
1517           {
1518             chartype[i]=OLE2NLS_CT_CType3_LUT[i];
1519           }
1520           return TRUE;
1521
1522         default:
1523           ERR("Unknown dwInfoType:%ld\n",dwInfoType);
1524           return FALSE;
1525         }
1526 }
1527
1528 /******************************************************************************
1529  *              GetStringTypeW  [KERNEL32.399]
1530  *
1531  * NOTES
1532  * Yes, this is missing LCID locale. MS fault.
1533  */
1534 BOOL WINAPI GetStringTypeW(DWORD dwInfoType,LPCWSTR src,INT cchSrc,
1535                                LPWORD chartype)
1536 {
1537         return GetStringTypeExW(0/*defaultlocale*/,dwInfoType,src,cchSrc,chartype);
1538 }
1539
1540 /******************************************************************************
1541  *              GetStringTypeExW        [KERNEL32.398]
1542  *
1543  * FIXME: unicode chars are assumed chars
1544  */
1545 BOOL WINAPI GetStringTypeExW(LCID locale,DWORD dwInfoType,LPCWSTR src,
1546                                  INT cchSrc,LPWORD chartype)
1547 {
1548         int     i;
1549
1550
1551         if (cchSrc==-1)
1552           cchSrc=lstrlenW(src)+1;
1553
1554         switch (dwInfoType) {
1555         case CT_CTYPE2:
1556                 FIXME("CT_CTYPE2 not supported.\n");
1557                 return FALSE;
1558         case CT_CTYPE3:
1559                 FIXME("CT_CTYPE3 not supported.\n");
1560                 return FALSE;
1561         default:break;
1562         }
1563         for (i=0;i<cchSrc;i++) {
1564                 chartype[i] = 0;
1565                 if (isdigit(src[i])) chartype[i]|=C1_DIGIT;
1566                 if (isalpha(src[i])) chartype[i]|=C1_ALPHA;
1567                 if (islower(src[i])) chartype[i]|=C1_LOWER;
1568                 if (isupper(src[i])) chartype[i]|=C1_UPPER;
1569                 if (isspace(src[i])) chartype[i]|=C1_SPACE;
1570                 if (ispunct(src[i])) chartype[i]|=C1_PUNCT;
1571                 if (iscntrl(src[i])) chartype[i]|=C1_CNTRL;
1572 /* FIXME: isblank() is a GNU extension */
1573 /*              if (isblank(src[i])) chartype[i]|=C1_BLANK; */
1574                 if ((src[i] == ' ') || (src[i] == '\t')) chartype[i]|=C1_BLANK;
1575                 /* C1_XDIGIT */
1576         }
1577         return TRUE;
1578 }
1579
1580 /*****************************************************************
1581  * WINE_GetLanguageName   [internal]
1582  */
1583 static LPCSTR WINE_GetLanguageName( UINT langid )
1584 {
1585     int i;
1586     for ( i = 0; languages[i].langid != 0; i++ )
1587         if ( langid == languages[i].langid )
1588             break;
1589
1590     return languages[i].langname;
1591 }
1592
1593 /***********************************************************************
1594  *           VerLanguageNameA              [KERNEL32.709][VERSION.9]
1595  */
1596 DWORD WINAPI VerLanguageNameA( UINT wLang, LPSTR szLang, UINT nSize )
1597 {
1598     char    buffer[80];
1599     LPCSTR  name;
1600     DWORD   result;
1601
1602     /*
1603      * First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
1604      * from the registry.
1605      */
1606
1607     sprintf( buffer,
1608              "\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",
1609              wLang );
1610
1611     result = RegQueryValueA( HKEY_LOCAL_MACHINE, buffer, szLang, (LPDWORD)&nSize );
1612     if ( result == ERROR_SUCCESS || result == ERROR_MORE_DATA )
1613         return nSize;
1614
1615     /*
1616      * If that fails, use the internal table
1617      */
1618
1619     name = WINE_GetLanguageName( wLang );
1620     lstrcpynA( szLang, name, nSize );
1621     return lstrlenA( name );
1622 }
1623
1624 /***********************************************************************
1625  *           VerLanguageNameW              [KERNEL32.710][VERSION.10]
1626  */
1627 DWORD WINAPI VerLanguageNameW( UINT wLang, LPWSTR szLang, UINT nSize )
1628 {
1629     char    buffer[80];
1630     LPWSTR  keyname;
1631     LPCSTR  name;
1632     DWORD   result;
1633
1634     /*
1635      * First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
1636      * from the registry.
1637      */
1638
1639     sprintf( buffer,
1640              "\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",
1641              wLang );
1642
1643     keyname = HEAP_strdupAtoW( GetProcessHeap(), 0, buffer );
1644     result = RegQueryValueW( HKEY_LOCAL_MACHINE, keyname, szLang, (LPDWORD)&nSize );
1645     HeapFree( GetProcessHeap(), 0, keyname );
1646
1647     if ( result == ERROR_SUCCESS || result == ERROR_MORE_DATA )
1648         return nSize;
1649
1650     /*
1651      * If that fails, use the internal table
1652      */
1653
1654     name = WINE_GetLanguageName( wLang );
1655     lstrcpynAtoW( szLang, name, nSize );
1656     return lstrlenA( name );
1657 }
1658
1659
1660 static const unsigned char LCM_Unicode_LUT[] = {
1661   6      ,   3, /*   -   1 */
1662   6      ,   4, /*   -   2 */
1663   6      ,   5, /*   -   3 */
1664   6      ,   6, /*   -   4 */
1665   6      ,   7, /*   -   5 */
1666   6      ,   8, /*   -   6 */
1667   6      ,   9, /*   -   7 */
1668   6      ,  10, /*   -   8 */
1669   7      ,   5, /*   -   9 */
1670   7      ,   6, /*   -  10 */
1671   7      ,   7, /*   -  11 */
1672   7      ,   8, /*   -  12 */
1673   7      ,   9, /*   -  13 */
1674   6      ,  11, /*   -  14 */
1675   6      ,  12, /*   -  15 */
1676   6      ,  13, /*   -  16 */
1677   6      ,  14, /*   -  17 */
1678   6      ,  15, /*   -  18 */
1679   6      ,  16, /*   -  19 */
1680   6      ,  17, /*   -  20 */
1681   6      ,  18, /*   -  21 */
1682   6      ,  19, /*   -  22 */
1683   6      ,  20, /*   -  23 */
1684   6      ,  21, /*   -  24 */
1685   6      ,  22, /*   -  25 */
1686   6      ,  23, /*   -  26 */
1687   6      ,  24, /*   -  27 */
1688   6      ,  25, /*   -  28 */
1689   6      ,  26, /*   -  29 */
1690   6      ,  27, /*   -  30 */
1691   6      ,  28, /*   -  31 */
1692   7      ,   2, /*   -  32 */
1693   7      ,  28, /* ! -  33 */
1694   7      ,  29, /* " -  34 */ /* " */
1695   7      ,  31, /* # -  35 */
1696   7      ,  33, /* $ -  36 */
1697   7      ,  35, /* % -  37 */
1698   7      ,  37, /* & -  38 */
1699   6      , 128, /* ' -  39 */
1700   7      ,  39, /* ( -  40 */
1701   7      ,  42, /* ) -  41 */
1702   7      ,  45, /* * -  42 */
1703   8      ,   3, /* + -  43 */
1704   7      ,  47, /* , -  44 */
1705   6      , 130, /* - -  45 */
1706   7      ,  51, /* . -  46 */
1707   7      ,  53, /* / -  47 */
1708  12      ,   3, /* 0 -  48 */
1709  12      ,  33, /* 1 -  49 */
1710  12      ,  51, /* 2 -  50 */
1711  12      ,  70, /* 3 -  51 */
1712  12      ,  88, /* 4 -  52 */
1713  12      , 106, /* 5 -  53 */
1714  12      , 125, /* 6 -  54 */
1715  12      , 144, /* 7 -  55 */
1716  12      , 162, /* 8 -  56 */
1717  12      , 180, /* 9 -  57 */
1718   7      ,  55, /* : -  58 */
1719   7      ,  58, /* ; -  59 */
1720   8      ,  14, /* < -  60 */
1721   8      ,  18, /* = -  61 */
1722   8      ,  20, /* > -  62 */
1723   7      ,  60, /* ? -  63 */
1724   7      ,  62, /* @ -  64 */
1725  14      ,   2, /* A -  65 */
1726  14      ,   9, /* B -  66 */
1727  14      ,  10, /* C -  67 */
1728  14      ,  26, /* D -  68 */
1729  14      ,  33, /* E -  69 */
1730  14      ,  35, /* F -  70 */
1731  14      ,  37, /* G -  71 */
1732  14      ,  44, /* H -  72 */
1733  14      ,  50, /* I -  73 */
1734  14      ,  53, /* J -  74 */
1735  14      ,  54, /* K -  75 */
1736  14      ,  72, /* L -  76 */
1737  14      ,  81, /* M -  77 */
1738  14      , 112, /* N -  78 */
1739  14      , 124, /* O -  79 */
1740  14      , 126, /* P -  80 */
1741  14      , 137, /* Q -  81 */
1742  14      , 138, /* R -  82 */
1743  14      , 145, /* S -  83 */
1744  14      , 153, /* T -  84 */
1745  14      , 159, /* U -  85 */
1746  14      , 162, /* V -  86 */
1747  14      , 164, /* W -  87 */
1748  14      , 166, /* X -  88 */
1749  14      , 167, /* Y -  89 */
1750  14      , 169, /* Z -  90 */
1751   7      ,  63, /* [ -  91 */
1752   7      ,  65, /* \ -  92 */
1753   7      ,  66, /* ] -  93 */
1754   7      ,  67, /* ^ -  94 */
1755   7      ,  68, /* _ -  95 */
1756   7      ,  72, /* ` -  96 */
1757  14      ,   2, /* a -  97 */
1758  14      ,   9, /* b -  98 */
1759  14      ,  10, /* c -  99 */
1760  14      ,  26, /* d - 100 */
1761  14      ,  33, /* e - 101 */
1762  14      ,  35, /* f - 102 */
1763  14      ,  37, /* g - 103 */
1764  14      ,  44, /* h - 104 */
1765  14      ,  50, /* i - 105 */
1766  14      ,  53, /* j - 106 */
1767  14      ,  54, /* k - 107 */
1768  14      ,  72, /* l - 108 */
1769  14      ,  81, /* m - 109 */
1770  14      , 112, /* n - 110 */
1771  14      , 124, /* o - 111 */
1772  14      , 126, /* p - 112 */
1773  14      , 137, /* q - 113 */
1774  14      , 138, /* r - 114 */
1775  14      , 145, /* s - 115 */
1776  14      , 153, /* t - 116 */
1777  14      , 159, /* u - 117 */
1778  14      , 162, /* v - 118 */
1779  14      , 164, /* w - 119 */
1780  14      , 166, /* x - 120 */
1781  14      , 167, /* y - 121 */
1782  14      , 169, /* z - 122 */
1783   7      ,  74, /* { - 123 */
1784   7      ,  76, /* | - 124 */
1785   7      ,  78, /* } - 125 */
1786   7      ,  80, /* ~ - 126 */
1787   6      ,  29, /* \7f - 127 */
1788   6      ,  30, /* \80 - 128 */
1789   6      ,  31, /* \81 - 129 */
1790   7      , 123, /* \82 - 130 */
1791  14      ,  35, /* \83 - 131 */
1792   7      , 127, /* \84 - 132 */
1793  10      ,  21, /* \85 - 133 */
1794  10      ,  15, /* \86 - 134 */
1795  10      ,  16, /* \87 - 135 */
1796   7      ,  67, /* \88 - 136 */
1797  10      ,  22, /* \89 - 137 */
1798  14      , 145, /* \8a - 138 */
1799   7      , 136, /* \8b - 139 */
1800  14 + 16 , 124, /* \8c - 140 */
1801   6      ,  43, /* \8d - 141 */
1802   6      ,  44, /* \8e - 142 */
1803   6      ,  45, /* \8f - 143 */
1804   6      ,  46, /* \90 - 144 */
1805   7      , 121, /* \91 - 145 */
1806   7      , 122, /* \92 - 146 */
1807   7      , 125, /* \93 - 147 */
1808   7      , 126, /* \94 - 148 */
1809  10      ,  17, /* \95 - 149 */
1810   6      , 137, /* \96 - 150 */
1811   6      , 139, /* \97 - 151 */
1812   7      ,  93, /* \98 - 152 */
1813  14      , 156, /* \99 - 153 */
1814  14      , 145, /* \9a - 154 */
1815   7      , 137, /* \9b - 155 */
1816  14 + 16 , 124, /* \9c - 156 */
1817   6      ,  59, /* \9d - 157 */
1818   6      ,  60, /* \9e - 158 */
1819  14      , 167, /* \9f - 159 */
1820   7      ,   4, /*   - 160 */
1821   7      ,  81, /* ¡ - 161 */
1822  10      ,   2, /* ¢ - 162 */
1823  10      ,   3, /* £ - 163 */
1824  10      ,   4, /* ¤ - 164 */
1825  10      ,   5, /* ¥ - 165 */
1826   7      ,  82, /* ¦ - 166 */
1827  10      ,   6, /* § - 167 */
1828   7      ,  83, /* ¨ - 168 */
1829  10      ,   7, /* © - 169 */
1830  14      ,   2, /* ª - 170 */
1831   8      ,  24, /* « - 171 */
1832  10      ,   8, /* ¬ - 172 */
1833   6      , 131, /*  - 173 */
1834  10      ,   9, /* ® - 174 */
1835   7      ,  84, /* ¯ - 175 */
1836  10      ,  10, /* ° - 176 */
1837   8      ,  23, /* ± - 177 */
1838  12      ,  51, /* ² - 178 */
1839  12      ,  70, /* ³ - 179 */
1840   7      ,  85, /* ´ - 180 */
1841  10      ,  11, /* µ - 181 */
1842  10      ,  12, /* ¶ - 182 */
1843  10      ,  13, /* · - 183 */
1844   7      ,  86, /* ¸ - 184 */
1845  12      ,  33, /* ¹ - 185 */
1846  14      , 124, /* º - 186 */
1847   8      ,  26, /* » - 187 */
1848  12      ,  21, /* ¼ - 188 */
1849  12      ,  25, /* ½ - 189 */
1850  12      ,  29, /* ¾ - 190 */
1851   7      ,  87, /* ¿ - 191 */
1852  14      ,   2, /* À - 192 */
1853  14      ,   2, /* Á - 193 */
1854  14      ,   2, /* Â - 194 */
1855  14      ,   2, /* Ã - 195 */
1856  14      ,   2, /* Ä - 196 */
1857  14      ,   2, /* Å - 197 */
1858  14 + 16 ,   2, /* Æ - 198 */
1859  14      ,  10, /* Ç - 199 */
1860  14      ,  33, /* È - 200 */
1861  14      ,  33, /* É - 201 */
1862  14      ,  33, /* Ê - 202 */
1863  14      ,  33, /* Ë - 203 */
1864  14      ,  50, /* Ì - 204 */
1865  14      ,  50, /* Í - 205 */
1866  14      ,  50, /* Î - 206 */
1867  14      ,  50, /* Ï - 207 */
1868  14      ,  26, /* Ð - 208 */
1869  14      , 112, /* Ñ - 209 */
1870  14      , 124, /* Ò - 210 */
1871  14      , 124, /* Ó - 211 */
1872  14      , 124, /* Ô - 212 */
1873  14      , 124, /* Õ - 213 */
1874  14      , 124, /* Ö - 214 */
1875   8      ,  28, /* × - 215 */
1876  14      , 124, /* Ø - 216 */
1877  14      , 159, /* Ù - 217 */
1878  14      , 159, /* Ú - 218 */
1879  14      , 159, /* Û - 219 */
1880  14      , 159, /* Ü - 220 */
1881  14      , 167, /* Ý - 221 */
1882  14 + 32 , 153, /* Þ - 222 */
1883  14 + 48 , 145, /* ß - 223 */
1884  14      ,   2, /* à - 224 */
1885  14      ,   2, /* á - 225 */
1886  14      ,   2, /* â - 226 */
1887  14      ,   2, /* ã - 227 */
1888  14      ,   2, /* ä - 228 */
1889  14      ,   2, /* å - 229 */
1890  14 + 16 ,   2, /* æ - 230 */
1891  14      ,  10, /* ç - 231 */
1892  14      ,  33, /* è - 232 */
1893  14      ,  33, /* é - 233 */
1894  14      ,  33, /* ê - 234 */
1895  14      ,  33, /* ë - 235 */
1896  14      ,  50, /* ì - 236 */
1897  14      ,  50, /* í - 237 */
1898  14      ,  50, /* î - 238 */
1899  14      ,  50, /* ï - 239 */
1900  14      ,  26, /* ð - 240 */
1901  14      , 112, /* ñ - 241 */
1902  14      , 124, /* ò - 242 */
1903  14      , 124, /* ó - 243 */
1904  14      , 124, /* ô - 244 */
1905  14      , 124, /* õ - 245 */
1906  14      , 124, /* ö - 246 */
1907   8      ,  29, /* ÷ - 247 */
1908  14      , 124, /* ø - 248 */
1909  14      , 159, /* ù - 249 */
1910  14      , 159, /* ú - 250 */
1911  14      , 159, /* û - 251 */
1912  14      , 159, /* ü - 252 */
1913  14      , 167, /* ý - 253 */
1914  14 + 32 , 153, /* þ - 254 */
1915  14      , 167  /* ÿ - 255 */ };
1916
1917 static const unsigned char LCM_Unicode_LUT_2[] = { 33, 44, 145 };
1918
1919 #define LCM_Diacritic_Start 131
1920
1921 static const unsigned char LCM_Diacritic_LUT[] = {
1922 123,  /* \83 - 131 */
1923   2,  /* \84 - 132 */
1924   2,  /* \85 - 133 */
1925   2,  /* \86 - 134 */
1926   2,  /* \87 - 135 */
1927   3,  /* \88 - 136 */
1928   2,  /* \89 - 137 */
1929  20,  /* \8a - 138 */
1930   2,  /* \8b - 139 */
1931   2,  /* \8c - 140 */
1932   2,  /* \8d - 141 */
1933   2,  /* \8e - 142 */
1934   2,  /* \8f - 143 */
1935   2,  /* \90 - 144 */
1936   2,  /* \91 - 145 */
1937   2,  /* \92 - 146 */
1938   2,  /* \93 - 147 */
1939   2,  /* \94 - 148 */
1940   2,  /* \95 - 149 */
1941   2,  /* \96 - 150 */
1942   2,  /* \97 - 151 */
1943   2,  /* \98 - 152 */
1944   2,  /* \99 - 153 */
1945  20,  /* \9a - 154 */
1946   2,  /* \9b - 155 */
1947   2,  /* \9c - 156 */
1948   2,  /* \9d - 157 */
1949   2,  /* \9e - 158 */
1950  19,  /* \9f - 159 */
1951   2,  /*   - 160 */
1952   2,  /* ¡ - 161 */
1953   2,  /* ¢ - 162 */
1954   2,  /* £ - 163 */
1955   2,  /* ¤ - 164 */
1956   2,  /* ¥ - 165 */
1957   2,  /* ¦ - 166 */
1958   2,  /* § - 167 */
1959   2,  /* ¨ - 168 */
1960   2,  /* © - 169 */
1961   3,  /* ª - 170 */
1962   2,  /* « - 171 */
1963   2,  /* ¬ - 172 */
1964   2,  /*  - 173 */
1965   2,  /* ® - 174 */
1966   2,  /* ¯ - 175 */
1967   2,  /* ° - 176 */
1968   2,  /* ± - 177 */
1969   2,  /* ² - 178 */
1970   2,  /* ³ - 179 */
1971   2,  /* ´ - 180 */
1972   2,  /* µ - 181 */
1973   2,  /* ¶ - 182 */
1974   2,  /* · - 183 */
1975   2,  /* ¸ - 184 */
1976   2,  /* ¹ - 185 */
1977   3,  /* º - 186 */
1978   2,  /* » - 187 */
1979   2,  /* ¼ - 188 */
1980   2,  /* ½ - 189 */
1981   2,  /* ¾ - 190 */
1982   2,  /* ¿ - 191 */
1983  15,  /* À - 192 */
1984  14,  /* Á - 193 */
1985  18,  /* Â - 194 */
1986  25,  /* Ã - 195 */
1987  19,  /* Ä - 196 */
1988  26,  /* Å - 197 */
1989   2,  /* Æ - 198 */
1990  28,  /* Ç - 199 */
1991  15,  /* È - 200 */
1992  14,  /* É - 201 */
1993  18,  /* Ê - 202 */
1994  19,  /* Ë - 203 */
1995  15,  /* Ì - 204 */
1996  14,  /* Í - 205 */
1997  18,  /* Î - 206 */
1998  19,  /* Ï - 207 */
1999 104,  /* Ð - 208 */
2000  25,  /* Ñ - 209 */
2001  15,  /* Ò - 210 */
2002  14,  /* Ó - 211 */
2003  18,  /* Ô - 212 */
2004  25,  /* Õ - 213 */
2005  19,  /* Ö - 214 */
2006   2,  /* × - 215 */
2007  33,  /* Ø - 216 */
2008  15,  /* Ù - 217 */
2009  14,  /* Ú - 218 */
2010  18,  /* Û - 219 */
2011  19,  /* Ü - 220 */
2012  14,  /* Ý - 221 */
2013   2,  /* Þ - 222 */
2014   2,  /* ß - 223 */
2015  15,  /* à - 224 */
2016  14,  /* á - 225 */
2017  18,  /* â - 226 */
2018  25,  /* ã - 227 */
2019  19,  /* ä - 228 */
2020  26,  /* å - 229 */
2021   2,  /* æ - 230 */
2022  28,  /* ç - 231 */
2023  15,  /* è - 232 */
2024  14,  /* é - 233 */
2025  18,  /* ê - 234 */
2026  19,  /* ë - 235 */
2027  15,  /* ì - 236 */
2028  14,  /* í - 237 */
2029  18,  /* î - 238 */
2030  19,  /* ï - 239 */
2031 104,  /* ð - 240 */
2032  25,  /* ñ - 241 */
2033  15,  /* ò - 242 */
2034  14,  /* ó - 243 */
2035  18,  /* ô - 244 */
2036  25,  /* õ - 245 */
2037  19,  /* ö - 246 */
2038   2,  /* ÷ - 247 */
2039  33,  /* ø - 248 */
2040  15,  /* ù - 249 */
2041  14,  /* ú - 250 */
2042  18,  /* û - 251 */
2043  19,  /* ü - 252 */
2044  14,  /* ý - 253 */
2045   2,  /* þ - 254 */
2046  19,  /* ÿ - 255 */
2047 } ;
2048
2049 /******************************************************************************
2050  * OLE2NLS_isPunctuation [INTERNAL]
2051  */
2052 static int OLE2NLS_isPunctuation(unsigned char c)
2053 {
2054   /* "punctuation character" in this context is a character which is
2055      considered "less important" during word sort comparison.
2056      See LCMapString implementation for the precise definition
2057      of "less important". */
2058
2059   return (LCM_Unicode_LUT[-2+2*c]==6);
2060 }
2061
2062 /******************************************************************************
2063  * OLE2NLS_isNonSpacing [INTERNAL]
2064  */
2065 static int OLE2NLS_isNonSpacing(unsigned char c)
2066 {
2067   /* This function is used by LCMapStringA.  Characters
2068      for which it returns true are ignored when mapping a
2069      string with NORM_IGNORENONSPACE */
2070   return ((c==136) || (c==170) || (c==186));
2071 }
2072
2073 /******************************************************************************
2074  * OLE2NLS_isSymbol [INTERNAL]
2075  */
2076 static int OLE2NLS_isSymbol(unsigned char c)
2077 {
2078   /* This function is used by LCMapStringA.  Characters
2079      for which it returns true are ignored when mapping a
2080      string with NORM_IGNORESYMBOLS */
2081   return ( (c!=0) && !IsCharAlphaNumericA(c) );
2082 }
2083
2084 /******************************************************************************
2085  *              identity        [Internal]
2086  */
2087 static int identity(int c)
2088 {
2089   return c;
2090 }
2091
2092 /*************************************************************************
2093  *              LCMapStringA                [KERNEL32.492]
2094  *
2095  * Convert a string, or generate a sort key from it.
2096  *
2097  * If (mapflags & LCMAP_SORTKEY), the function will generate
2098  * a sort key for the source string.  Else, it will convert it
2099  * accordingly to the flags LCMAP_UPPERCASE, LCMAP_LOWERCASE,...
2100  *
2101  * RETURNS
2102  *    Error : 0.
2103  *    Success : length of the result string.
2104  *
2105  * NOTES
2106  *    If called with scrlen = -1, the function will compute the length
2107  *      of the 0-terminated string strsrc by itself.
2108  *
2109  *    If called with dstlen = 0, returns the buffer length that
2110  *      would be required.
2111  *
2112  *    NORM_IGNOREWIDTH means to compare ASCII and wide characters
2113  *    as if they are equal.
2114  *    In the only code page implemented so far, there may not be
2115  *    wide characters in strings passed to LCMapStringA,
2116  *    so there is nothing to be done for this flag.
2117  */
2118 INT WINAPI LCMapStringA(
2119         LCID lcid /* locale identifier created with MAKELCID;
2120                      LOCALE_SYSTEM_DEFAULT and LOCALE_USER_DEFAULT are
2121                      predefined values. */,
2122         DWORD mapflags /* flags */,
2123         LPCSTR srcstr  /* source buffer */,
2124         INT srclen   /* source length */,
2125         LPSTR dststr   /* destination buffer */,
2126         INT dstlen   /* destination buffer length */)
2127 {
2128   int i;
2129
2130   TRACE_(string)("(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
2131         lcid,mapflags,srcstr,srclen,dststr,dstlen);
2132
2133   if ( ((dstlen!=0) && (dststr==NULL)) || (srcstr==NULL) )
2134   {
2135     ERR("(src=%s,dest=%s): Invalid NULL string\n", srcstr, dststr);
2136     SetLastError(ERROR_INVALID_PARAMETER);
2137     return 0;
2138   }
2139   if (srclen == -1)
2140     srclen = lstrlenA(srcstr) + 1 ;    /* (include final '\0') */
2141
2142 #define LCMAPSTRINGA_SUPPORTED_FLAGS (LCMAP_UPPERCASE     | \
2143                                         LCMAP_LOWERCASE     | \
2144                                         LCMAP_SORTKEY       | \
2145                                         NORM_IGNORECASE     | \
2146                                         NORM_IGNORENONSPACE | \
2147                                         SORT_STRINGSORT     | \
2148                                         NORM_IGNOREWIDTH    | \
2149                                         NORM_IGNOREKANATYPE)
2150   /* FIXME: as long as we don't support Kanakana nor Hirigana
2151    * characters, we can support NORM_IGNOREKANATYPE
2152    */
2153   if (mapflags & ~LCMAPSTRINGA_SUPPORTED_FLAGS)
2154   {
2155     FIXME_(string)("(0x%04lx,0x%08lx,%p,%d,%p,%d): "
2156           "unimplemented flags: 0x%08lx\n",
2157           lcid,
2158           mapflags,
2159           srcstr,
2160           srclen,
2161           dststr,
2162           dstlen,
2163           mapflags & ~LCMAPSTRINGA_SUPPORTED_FLAGS
2164      );
2165   }
2166
2167   if ( !(mapflags & LCMAP_SORTKEY) )
2168   {
2169     int i,j;
2170     int (*f)(int) = identity;
2171     int flag_ignorenonspace = mapflags & NORM_IGNORENONSPACE;
2172     int flag_ignoresymbols = mapflags & NORM_IGNORESYMBOLS;
2173
2174     if (flag_ignorenonspace || flag_ignoresymbols)
2175     {
2176       /* For some values of mapflags, the length of the resulting
2177          string is not known at this point.  Windows does map the string
2178          and does not SetLastError ERROR_INSUFFICIENT_BUFFER in
2179          these cases. */
2180       if (dstlen==0)
2181       {
2182         /* Compute required length */
2183         for (i=j=0; i < srclen; i++)
2184         {
2185           if ( !(flag_ignorenonspace && OLE2NLS_isNonSpacing(srcstr[i]))
2186                && !(flag_ignoresymbols && OLE2NLS_isSymbol(srcstr[i])) )
2187             j++;
2188         }
2189         return j;
2190       }
2191     }
2192     else
2193     {
2194       if (dstlen==0)
2195         return srclen;
2196       if (dstlen<srclen)
2197            {
2198              SetLastError(ERROR_INSUFFICIENT_BUFFER);
2199              return 0;
2200            }
2201     }
2202     if (mapflags & LCMAP_UPPERCASE)
2203       f = toupper;
2204     else if (mapflags & LCMAP_LOWERCASE)
2205       f = tolower;
2206     /* FIXME: NORM_IGNORENONSPACE requires another conversion */
2207     for (i=j=0; (i<srclen) && (j<dstlen) ; i++)
2208     {
2209       if ( !(flag_ignorenonspace && OLE2NLS_isNonSpacing(srcstr[i]))
2210            && !(flag_ignoresymbols && OLE2NLS_isSymbol(srcstr[i])) )
2211       {
2212         dststr[j] = (CHAR) f(srcstr[i]);
2213         j++;
2214       }
2215     }
2216     return j;
2217   }
2218
2219   /* FIXME: This function completely ignores the "lcid" parameter. */
2220   /* else ... (mapflags & LCMAP_SORTKEY)  */
2221   {
2222     int unicode_len=0;
2223     int case_len=0;
2224     int diacritic_len=0;
2225     int delayed_punctuation_len=0;
2226     char *case_component;
2227     char *diacritic_component;
2228     char *delayed_punctuation_component;
2229     int room,count;
2230     int flag_stringsort = mapflags & SORT_STRINGSORT;
2231
2232     /* compute how much room we will need */
2233     for (i=0;i<srclen;i++)
2234     {
2235       int ofs;
2236       unsigned char source_char = srcstr[i];
2237       if (source_char!='\0')
2238       {
2239         if (flag_stringsort || !OLE2NLS_isPunctuation(source_char))
2240         {
2241           unicode_len++;
2242           if ( LCM_Unicode_LUT[-2+2*source_char] & ~15 )
2243             unicode_len++;             /* double letter */
2244         }
2245         else
2246         {
2247           delayed_punctuation_len++;
2248         }
2249       }
2250
2251       if (isupper(source_char))
2252         case_len=unicode_len;
2253
2254       ofs = source_char - LCM_Diacritic_Start;
2255       if ((ofs>=0) && (LCM_Diacritic_LUT[ofs]!=2))
2256         diacritic_len=unicode_len;
2257     }
2258
2259     if (mapflags & NORM_IGNORECASE)
2260       case_len=0;
2261     if (mapflags & NORM_IGNORENONSPACE)
2262       diacritic_len=0;
2263
2264     room =  2 * unicode_len              /* "unicode" component */
2265       +     diacritic_len                /* "diacritic" component */
2266       +     case_len                     /* "case" component */
2267       +     4 * delayed_punctuation_len  /* punctuation in word sort mode */
2268       +     4                            /* four '\1' separators */
2269       +     1  ;                         /* terminal '\0' */
2270     if (dstlen==0)
2271       return room;
2272     else if (dstlen<room)
2273     {
2274       SetLastError(ERROR_INSUFFICIENT_BUFFER);
2275       return 0;
2276     }
2277
2278     /*FIXME the Pointercheck should not be nessesary */
2279     if (IsBadWritePtr (dststr,room))
2280     { ERR_(string)("bad destination buffer (dststr) : %p,%d\n",dststr,dstlen);
2281       SetLastError(ERROR_INSUFFICIENT_BUFFER);
2282       return 0;
2283     }
2284
2285     /* locate each component, write separators */
2286     diacritic_component = dststr + 2*unicode_len ;
2287     *diacritic_component++ = '\1';
2288     case_component = diacritic_component + diacritic_len ;
2289     *case_component++ = '\1';
2290     delayed_punctuation_component = case_component + case_len ;
2291     *delayed_punctuation_component++ = '\1';
2292     *delayed_punctuation_component++ = '\1';
2293
2294     /* read source string char by char, write
2295        corresponding weight in each component. */
2296     for (i=0,count=0;i<srclen;i++)
2297     {
2298       unsigned char source_char=srcstr[i];
2299       if (source_char!='\0')
2300       {
2301         int type,longcode;
2302         type = LCM_Unicode_LUT[-2+2*source_char];
2303         longcode = type >> 4;
2304         type &= 15;
2305         if (!flag_stringsort && OLE2NLS_isPunctuation(source_char))
2306         {
2307           UINT16 encrypted_location = (1<<15) + 7 + 4*count;
2308           *delayed_punctuation_component++ = (unsigned char) (encrypted_location>>8);
2309           *delayed_punctuation_component++ = (unsigned char) (encrypted_location&255);
2310                      /* big-endian is used here because it lets string comparison be
2311                         compatible with numerical comparison */
2312
2313           *delayed_punctuation_component++ = type;
2314           *delayed_punctuation_component++ = LCM_Unicode_LUT[-1+2*source_char];
2315                      /* assumption : a punctuation character is never a
2316                         double or accented letter */
2317         }
2318         else
2319         {
2320           dststr[2*count] = type;
2321           dststr[2*count+1] = LCM_Unicode_LUT[-1+2*source_char];
2322           if (longcode)
2323           {
2324             if (count<case_len)
2325               case_component[count] = ( isupper(source_char) ? 18 : 2 ) ;
2326             if (count<diacritic_len)
2327               diacritic_component[count] = 2; /* assumption: a double letter
2328                                                  is never accented */
2329             count++;
2330
2331             dststr[2*count] = type;
2332             dststr[2*count+1] = *(LCM_Unicode_LUT_2 - 1 + longcode);
2333             /* 16 in the first column of LCM_Unicode_LUT  -->  longcode = 1
2334                32 in the first column of LCM_Unicode_LUT  -->  longcode = 2
2335                48 in the first column of LCM_Unicode_LUT  -->  longcode = 3 */
2336           }
2337
2338           if (count<case_len)
2339             case_component[count] = ( isupper(source_char) ? 18 : 2 ) ;
2340           if (count<diacritic_len)
2341           {
2342             int ofs = source_char - LCM_Diacritic_Start;
2343             diacritic_component[count] = (ofs>=0 ? LCM_Diacritic_LUT[ofs] : 2);
2344           }
2345           count++;
2346         }
2347       }
2348     }
2349     dststr[room-1] = '\0';
2350     return room;
2351   }
2352 }
2353
2354 /*************************************************************************
2355  *              LCMapStringW                [KERNEL32.493]
2356  *
2357  * Convert a string, or generate a sort key from it.
2358  *
2359  * NOTE
2360  *
2361  * See LCMapStringA for documentation
2362  */
2363 INT WINAPI LCMapStringW(
2364         LCID lcid,DWORD mapflags,LPCWSTR srcstr,INT srclen,LPWSTR dststr,
2365         INT dstlen)
2366 {
2367   int i;
2368
2369   TRACE_(string)("(0x%04lx,0x%08lx,%p,%d,%p,%d)\n",
2370                  lcid, mapflags, srcstr, srclen, dststr, dstlen);
2371
2372   if ( ((dstlen!=0) && (dststr==NULL)) || (srcstr==NULL) )
2373   {
2374     ERR("(src=%p,dst=%p): Invalid NULL string\n", srcstr, dststr);
2375     SetLastError(ERROR_INVALID_PARAMETER);
2376     return 0;
2377   }
2378   if (srclen==-1)
2379     srclen = lstrlenW(srcstr)+1;
2380
2381   /* FIXME: Both this function and it's companion LCMapStringA()
2382    * completely ignore the "lcid" parameter.  In place of the "lcid"
2383    * parameter the application must set the "LC_COLLATE" or "LC_ALL"
2384    * environment variable prior to invoking this function.  */
2385   if (mapflags & LCMAP_SORTKEY)
2386   {
2387       /* Possible values of LC_COLLATE. */
2388       char *lc_collate_default = 0; /* value prior to this function */
2389       char *lc_collate_env = 0;     /* value retrieved from the environment */
2390
2391       /* General purpose index into strings of any type. */
2392       int str_idx = 0;
2393
2394       /* Lengths of various strings where the length is measured in
2395        * wide characters for wide character strings and in bytes for
2396        * native strings.  The lengths include the NULL terminator.  */
2397       size_t returned_len    = 0;
2398       size_t src_native_len  = 0;
2399       size_t dst_native_len  = 0;
2400       size_t dststr_libc_len = 0;
2401
2402       /* Native (character set determined by locale) versions of the
2403        * strings source and destination strings.  */
2404       LPSTR src_native = 0;
2405       LPSTR dst_native = 0;
2406
2407       /* Version of the source and destination strings using the
2408        * "wchar_t" Unicode data type needed by various libc functions.  */
2409       wchar_t *srcstr_libc = 0;
2410       wchar_t *dststr_libc = 0;
2411
2412       if(!(srcstr_libc = (wchar_t *)HeapAlloc(GetProcessHeap(), 0,
2413                                        srclen * sizeof(wchar_t))))
2414       {
2415           ERR("Unable to allocate %d bytes for srcstr_libc\n",
2416               srclen * sizeof(wchar_t));
2417           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2418           return 0;
2419       }
2420
2421       /* Convert source string to a libc Unicode string. */
2422       for(str_idx = 0; str_idx < srclen; str_idx++)
2423       {
2424           srcstr_libc[str_idx] = srcstr[str_idx];
2425       }
2426
2427       /* src_native should contain at most 3 bytes for each
2428        * multibyte characters in the original srcstr string.  */
2429       src_native_len = 3 * srclen;
2430       if(!(src_native = (LPSTR)HeapAlloc(GetProcessHeap(), 0,
2431                                           src_native_len)))
2432       {
2433           ERR("Unable to allocate %d bytes for src_native\n", src_native_len);
2434           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2435           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2436           return 0;
2437       }
2438
2439       /* FIXME: Prior to to setting the LC_COLLATE locale category the
2440        * current value is backed up so it can be restored after the
2441        * last LC_COLLATE sensitive function returns.
2442        *
2443        * Even though the locale is adjusted for a minimum amount of
2444        * time a race condition exists where other threads may be
2445        * affected if they invoke LC_COLLATE sensitive functions.  One
2446        * possible solution is to wrap all LC_COLLATE sensitive Wine
2447        * functions, like LCMapStringW(), in a mutex.
2448        *
2449        * Another enhancement to the following would be to set the
2450        * LC_COLLATE locale category as a function of the "lcid"
2451        * parameter instead of the "LC_COLLATE" environment variable. */
2452       if(!(lc_collate_default = setlocale(LC_COLLATE, NULL)))
2453       {
2454           ERR("Unable to query the LC_COLLATE catagory\n");
2455           SetLastError(ERROR_INVALID_PARAMETER);
2456           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2457           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2458           return 0;
2459       }
2460
2461       if(!(lc_collate_env = setlocale(LC_COLLATE, "")))
2462       {
2463           ERR("Unable to inherit the LC_COLLATE locale category from the "
2464               "environment.  The \"LC_COLLATE\" environment variable is "
2465               "\"%s\".\n", getenv("LC_COLLATE") ?
2466               getenv("LC_COLLATE") : "<unset>");
2467           SetLastError(ERROR_INVALID_PARAMETER);
2468           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2469           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2470           return 0;
2471       }
2472
2473       TRACE_(string)("lc_collate_default = %s\n", lc_collate_default);
2474       TRACE_(string)("lc_collate_env = %s\n", lc_collate_env);
2475
2476       /* Convert the libc Unicode string to a native multibyte character
2477        * string. */
2478       returned_len = wcstombs(src_native, srcstr_libc, src_native_len) + 1;
2479       if(returned_len == 0)
2480       {
2481           LPSTR srcstr_ascii = (LPSTR)HEAP_strdupWtoA(GetProcessHeap(),
2482                                            0, srcstr);
2483           ERR("wcstombs failed.  The string specified (%s) may contains an "
2484               "invalid character.\n", srcstr_ascii);
2485           SetLastError(ERROR_INVALID_PARAMETER);
2486           if(srcstr_ascii) HeapFree(GetProcessHeap(), 0, srcstr_ascii);
2487           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2488           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2489           setlocale(LC_COLLATE, lc_collate_default);
2490           return 0;
2491       }
2492       else if(returned_len > src_native_len)
2493       {
2494           src_native[src_native_len - 1] = 0;
2495           ERR("wcstombs returned a string (%s) that was longer (%d bytes) "
2496               "than expected (%d bytes).\n", src_native, returned_len,
2497               dst_native_len);
2498
2499           /* Since this is an internal error I'm not sure what the correct
2500            * error code is.  */
2501           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2502
2503           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2504           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2505           setlocale(LC_COLLATE, lc_collate_default);
2506           return 0;
2507       }
2508       src_native_len = returned_len;
2509
2510       TRACE_(string)("src_native = %s  src_native_len = %d\n",
2511              src_native, src_native_len);
2512
2513       /* dst_native seems to contain at most 4 bytes for each byte in
2514        * the original src_native string.  Change if need be since this
2515        * isn't documented by the strxfrm() man page. */
2516       dst_native_len = 4 * src_native_len;
2517       if(!(dst_native = (LPSTR)HeapAlloc(GetProcessHeap(), 0, dst_native_len)))
2518       {
2519           ERR("Unable to allocate %d bytes for dst_native\n", dst_native_len);
2520           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2521           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2522           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2523           setlocale(LC_COLLATE, lc_collate_default);
2524           return 0;
2525       }
2526
2527       /* The actual translation is done by the following call to
2528        * strxfrm().  The surrounding code could have been simplified
2529        * by calling wcsxfrm() instead except that wcsxfrm() is not
2530        * available on older Linux systems (RedHat 4.1 with
2531        * libc-5.3.12-17).
2532        *
2533        * Also, it is possible that the translation could be done by
2534        * various tables as it is done in LCMapStringA().  However, I'm
2535        * not sure what those tables are. */
2536       returned_len = strxfrm(dst_native, src_native, dst_native_len) + 1;
2537
2538       if(returned_len > dst_native_len)
2539       {
2540           dst_native[dst_native_len - 1] = 0;
2541           ERR("strxfrm returned a string (%s) that was longer (%d bytes) "
2542               "than expected (%d bytes).\n", dst_native, returned_len,
2543               dst_native_len);
2544
2545           /* Since this is an internal error I'm not sure what the correct
2546            * error code is.  */
2547           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2548
2549           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2550           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2551           if(dst_native) HeapFree(GetProcessHeap(), 0, dst_native);
2552           setlocale(LC_COLLATE, lc_collate_default);
2553           return 0;
2554       }
2555       dst_native_len = returned_len;
2556
2557       TRACE_(string)("dst_native = %s  dst_native_len = %d\n",
2558              dst_native, dst_native_len);
2559
2560       dststr_libc_len = dst_native_len;
2561       if(!(dststr_libc = (wchar_t *)HeapAlloc(GetProcessHeap(), 0,
2562                                        dststr_libc_len * sizeof(wchar_t))))
2563       {
2564           ERR("Unable to allocate %d bytes for dststr_libc\n",
2565               dststr_libc_len * sizeof(wchar_t));
2566           SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2567           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2568           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2569           if(dst_native) HeapFree(GetProcessHeap(), 0, dst_native);
2570           setlocale(LC_COLLATE, lc_collate_default);
2571           return 0;
2572       }
2573
2574       /* Convert the native multibyte string to a libc Unicode string. */
2575       returned_len = mbstowcs(dststr_libc, dst_native, dst_native_len) + 1;
2576
2577       /* Restore LC_COLLATE now that the last LC_COLLATE sensitive
2578        * function has returned. */
2579       setlocale(LC_COLLATE, lc_collate_default);
2580
2581       if(returned_len == 0)
2582       {
2583           ERR("mbstowcs failed.  The native version of the translated string "
2584               "(%s) may contain an invalid character.\n", dst_native);
2585           SetLastError(ERROR_INVALID_PARAMETER);
2586           if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2587           if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2588           if(dst_native) HeapFree(GetProcessHeap(), 0, dst_native);
2589           if(dststr_libc) HeapFree(GetProcessHeap(), 0, dststr_libc);
2590           return 0;
2591       }
2592       if(dstlen)
2593       {
2594           if(returned_len > dstlen)
2595           {
2596               ERR("mbstowcs returned a string that was longer (%d chars) "
2597                   "than the buffer provided (%d chars).\n", returned_len,
2598                   dstlen);
2599               SetLastError(ERROR_INSUFFICIENT_BUFFER);
2600               if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2601               if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2602               if(dst_native) HeapFree(GetProcessHeap(), 0, dst_native);
2603               if(dststr_libc) HeapFree(GetProcessHeap(), 0, dststr_libc);
2604               return 0;
2605           }
2606           dstlen = returned_len;
2607
2608           /* Convert a libc Unicode string to the destination string. */
2609           for(str_idx = 0; str_idx < dstlen; str_idx++)
2610           {
2611               dststr[str_idx] = dststr_libc[str_idx];
2612           }
2613           TRACE_(string)("1st 4 int sized chunks of dststr = %x %x %x %x\n",
2614                          *(((int *)dststr) + 0),
2615                          *(((int *)dststr) + 1),
2616                          *(((int *)dststr) + 2),
2617                          *(((int *)dststr) + 3));
2618       }
2619       else
2620       {
2621           dstlen = returned_len;
2622       }
2623       TRACE_(string)("dstlen (return) = %d\n", dstlen);
2624       if(srcstr_libc) HeapFree(GetProcessHeap(), 0, srcstr_libc);
2625       if(src_native) HeapFree(GetProcessHeap(), 0, src_native);
2626       if(dst_native) HeapFree(GetProcessHeap(), 0, dst_native);
2627       if(dststr_libc) HeapFree(GetProcessHeap(), 0, dststr_libc);
2628       return dstlen;
2629   }
2630   else
2631   {
2632     int (*f)(int)=identity;
2633
2634     if (dstlen==0)
2635         return srclen;
2636     if (dstlen<srclen)
2637     {
2638         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2639         return 0;
2640     }
2641
2642     if (mapflags & LCMAP_UPPERCASE)
2643       f = toupper;
2644     else if (mapflags & LCMAP_LOWERCASE)
2645       f = tolower;
2646     for (i=0; i < srclen; i++)
2647       dststr[i] = (WCHAR) f(srcstr[i]);
2648     return srclen;
2649   }
2650 }
2651
2652 /***********************************************************************
2653  *           CompareString16       (OLE2NLS.8)
2654  */
2655 UINT16 WINAPI CompareString16(DWORD lcid,DWORD fdwStyle,
2656                               LPCSTR s1,DWORD l1,LPCSTR s2,DWORD l2)
2657 {
2658         return (UINT16)CompareStringA(lcid,fdwStyle,s1,l1,s2,l2);
2659 }
2660
2661 /***********************************************************************
2662  *           OLE2NLS_EstimateMappingLength
2663  *
2664  * Estimates the number of characters required to hold the string
2665  * computed by LCMapStringA.
2666  *
2667  * The size is always over-estimated, with a fixed limit on the
2668  * amount of estimation error.
2669  *
2670  * Note that len == -1 is not permitted.
2671  */
2672 static inline int OLE2NLS_EstimateMappingLength(LCID lcid, DWORD dwMapFlags,
2673                                                 LPCSTR str, DWORD len)
2674 {
2675     /* Estimate only for small strings to keep the estimation error from
2676      * becoming too large. */
2677     if (len < 128) return len * 8 + 5;
2678     else return LCMapStringA(lcid, dwMapFlags, str, len, NULL, 0);
2679 }
2680
2681 /******************************************************************************
2682  *              CompareStringA  [KERNEL32.143]
2683  * Compares two strings using locale
2684  *
2685  * RETURNS
2686  *
2687  * success: CSTR_LESS_THAN, CSTR_EQUAL, CSTR_GREATER_THAN
2688  * failure: 0
2689  *
2690  * NOTES
2691  *
2692  * Defaults to a word sort, but uses a string sort if
2693  * SORT_STRINGSORT is set.
2694  * Calls SetLastError for ERROR_INVALID_FLAGS, ERROR_INVALID_PARAMETER.
2695  *
2696  * BUGS
2697  *
2698  * This implementation ignores the locale
2699  *
2700  * FIXME
2701  *
2702  * Quite inefficient.
2703  */
2704 UINT WINAPI CompareStringA(
2705     DWORD lcid,     /* locale ID */
2706     DWORD fdwStyle, /* comparison-style options */
2707     LPCSTR s1,      /* first string */
2708     DWORD l1,       /* length of first string */
2709     LPCSTR s2,      /* second string */
2710     DWORD l2)       /* length of second string */
2711 {
2712   int mapstring_flags;
2713   int len1,len2;
2714   int result;
2715   LPSTR sk1,sk2;
2716   TRACE("%s and %s\n",
2717         debugstr_a (s1), debugstr_a (s2));
2718
2719   if ( (s1==NULL) || (s2==NULL) )
2720   {
2721     ERR("(s1=%s,s2=%s): Invalid NULL string\n", s1, s2);
2722     SetLastError(ERROR_INVALID_PARAMETER);
2723     return 0;
2724   }
2725
2726   if(fdwStyle & NORM_IGNORESYMBOLS)
2727     FIXME("IGNORESYMBOLS not supported\n");
2728
2729   if (l1 == -1) l1 = lstrlenA(s1);
2730   if (l2 == -1) l2 = lstrlenA(s2);
2731
2732   mapstring_flags = LCMAP_SORTKEY | fdwStyle ;
2733   len1 = OLE2NLS_EstimateMappingLength(lcid, mapstring_flags, s1, l1);
2734   len2 = OLE2NLS_EstimateMappingLength(lcid, mapstring_flags, s2, l2);
2735
2736   if ((len1==0)||(len2==0))
2737     return 0;     /* something wrong happened */
2738
2739   sk1 = (LPSTR)HeapAlloc(GetProcessHeap(), 0, len1 + len2);
2740   sk2 = sk1 + len1;
2741   if ( (!LCMapStringA(lcid,mapstring_flags,s1,l1,sk1,len1))
2742          || (!LCMapStringA(lcid,mapstring_flags,s2,l2,sk2,len2)) )
2743   {
2744     ERR("Bug in LCmapStringA.\n");
2745     result = 0;
2746   }
2747   else
2748   {
2749     /* strcmp doesn't necessarily return -1, 0, or 1 */
2750     result = strcmp(sk1,sk2);
2751   }
2752   HeapFree(GetProcessHeap(),0,sk1);
2753
2754   if (result < 0)
2755     return 1;
2756   if (result == 0)
2757     return 2;
2758
2759   /* must be greater, if we reach this point */
2760   return 3;
2761 }
2762
2763 /******************************************************************************
2764  *              CompareStringW  [KERNEL32.144]
2765  * This implementation ignores the locale
2766  * FIXME :  Does only string sort.  Should
2767  * be reimplemented the same way as CompareStringA.
2768  */
2769 UINT WINAPI CompareStringW(DWORD lcid, DWORD fdwStyle,
2770                                LPCWSTR s1, DWORD l1, LPCWSTR s2,DWORD l2)
2771 {
2772         int len,ret;
2773         if(fdwStyle & NORM_IGNORENONSPACE)
2774                 FIXME("IGNORENONSPACE not supprted\n");
2775         if(fdwStyle & NORM_IGNORESYMBOLS)
2776                 FIXME("IGNORESYMBOLS not supported\n");
2777
2778         /* Is strcmp defaulting to string sort or to word sort?? */
2779         /* FIXME: Handle NORM_STRINGSORT */
2780         l1 = (l1==-1)?lstrlenW(s1):l1;
2781         l2 = (l2==-1)?lstrlenW(s2):l2;
2782         len = l1<l2 ? l1:l2;
2783         ret = (fdwStyle & NORM_IGNORECASE) ?
2784                 CRTDLL__wcsnicmp(s1,s2,len) : CRTDLL_wcsncmp(s1,s2,len);
2785         /* not equal, return 1 or 3 */
2786         if(ret!=0) return ret+2;
2787         /* same len, return 2 */
2788         if(l1==l2) return 2;
2789         /* the longer one is lexically greater */
2790         return (l1<l2)? 1 : 3;
2791 }
2792
2793 /******************************************************************************
2794  *      RegisterNLSInfoChanged  [OLE2NLS.10]
2795  */
2796 BOOL16 WINAPI RegisterNLSInfoChanged16(LPVOID/*FIXME*/ lpNewNLSInfo)
2797 {
2798         FIXME("Fully implemented, but doesn't effect anything.\n");
2799
2800         if (!lpNewNLSInfo)
2801         {
2802                 lpNLSInfo = NULL;
2803                 return TRUE;
2804         }
2805         else
2806         {
2807                 if (!lpNLSInfo)
2808                 {
2809                         lpNLSInfo = lpNewNLSInfo;
2810                         return TRUE;
2811                 }
2812         }
2813
2814         return FALSE; /* ptr not set */
2815 }
2816
2817 /******************************************************************************
2818  *              OLE_GetFormatA  [Internal]
2819  *
2820  * FIXME
2821  *    If datelen == 0, it should return the reguired string length.
2822  *
2823  This function implements stuff for GetDateFormat() and
2824  GetTimeFormat().
2825
2826   d    single-digit (no leading zero) day (of month)
2827   dd   two-digit day (of month)
2828   ddd  short day-of-week name
2829   dddd long day-of-week name
2830   M    single-digit month
2831   MM   two-digit month
2832   MMM  short month name
2833   MMMM full month name
2834   y    two-digit year, no leading 0
2835   yy   two-digit year
2836   yyyy four-digit year
2837   gg   era string
2838   h    hours with no leading zero (12-hour)
2839   hh   hours with full two digits
2840   H    hours with no leading zero (24-hour)
2841   HH   hours with full two digits
2842   m    minutes with no leading zero
2843   mm   minutes with full two digits
2844   s    seconds with no leading zero
2845   ss   seconds with full two digits
2846   t    time marker (A or P)
2847   tt   time marker (AM, PM)
2848   ''   used to quote literal characters
2849   ''   (within a quoted string) indicates a literal '
2850
2851  These functions REQUIRE valid locale, date,  and format.
2852  */
2853 static INT OLE_GetFormatA(LCID locale,
2854                             DWORD flags,
2855                             DWORD tflags,
2856                             LPSYSTEMTIME xtime,
2857                             LPCSTR _format,     /*in*/
2858                             LPSTR date,         /*out*/
2859                             INT datelen)
2860 {
2861    INT inpos, outpos;
2862    int count, type, inquote, Overflow;
2863    char buf[40];
2864    char format[40];
2865    char * pos;
2866    int buflen;
2867
2868    const char * _dgfmt[] = { "%d", "%02d" };
2869    const char ** dgfmt = _dgfmt - 1;
2870
2871    /* report, for debugging */
2872    TRACE("(0x%lx,0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt=%p \'%s\' , %p, len=%d)\n",
2873          locale, flags, tflags,
2874          xtime->wDay, xtime->wHour, xtime->wMinute, xtime->wSecond,
2875          _format, _format, date, datelen);
2876
2877    if(datelen == 0) {
2878      FIXME("datelen = 0, returning 255\n");
2879      return 255;
2880    }
2881
2882    /* initalize state variables and output buffer */
2883    inpos = outpos = 0;
2884    count = 0; inquote = 0; Overflow = 0;
2885    type = '\0';
2886    date[0] = buf[0] = '\0';
2887
2888    strcpy(format,_format);
2889
2890    /* alter the formatstring, while it works for all languages now in wine
2891    its possible that it fails when the time looks like ss:mm:hh as example*/
2892    if (tflags & (TIME_NOMINUTESORSECONDS))
2893    { if ((pos = strstr ( format, ":mm")))
2894      { memcpy ( pos, pos+3, strlen(format)-(pos-format)-2 );
2895      }
2896    }
2897    if (tflags & (TIME_NOSECONDS))
2898    { if ((pos = strstr ( format, ":ss")))
2899      { memcpy ( pos, pos+3, strlen(format)-(pos-format)-2 );
2900      }
2901    }
2902
2903    for (inpos = 0;; inpos++) {
2904       /* TRACE(ole, "STATE inpos=%2d outpos=%2d count=%d inquote=%d type=%c buf,date = %c,%c\n", inpos, outpos, count, inquote, type, buf[inpos], date[outpos]); */
2905       if (inquote) {
2906          if (format[inpos] == '\'') {
2907             if (format[inpos+1] == '\'') {
2908                inpos += 1;
2909                date[outpos++] = '\'';
2910             } else {
2911                inquote = 0;
2912                continue; /* we did nothing to the output */
2913             }
2914          } else if (format[inpos] == '\0') {
2915             date[outpos++] = '\0';
2916             if (outpos > datelen) Overflow = 1;
2917             break;
2918          } else {
2919             date[outpos++] = format[inpos];
2920             if (outpos > datelen) {
2921                Overflow = 1;
2922                date[outpos-1] = '\0'; /* this is the last place where
2923                                          it's safe to write */
2924                break;
2925             }
2926          }
2927       } else if (  (count && (format[inpos] != type))
2928                    || count == 4
2929                    || (count == 2 && strchr("ghHmst", type)) )
2930        {
2931             if         (type == 'd') {
2932                if        (count == 4) {
2933                   GetLocaleInfoA(locale,
2934                                    LOCALE_SDAYNAME1
2935                                    + xtime->wDayOfWeek - 1,
2936                                    buf, sizeof(buf));
2937                } else if (count == 3) {
2938                            GetLocaleInfoA(locale,
2939                                             LOCALE_SABBREVDAYNAME1
2940                                             + xtime->wDayOfWeek - 1,
2941                                             buf, sizeof(buf));
2942                       } else {
2943                   sprintf(buf, dgfmt[count], xtime->wDay);
2944                }
2945             } else if (type == 'M') {
2946                if (count == 3) {
2947                   GetLocaleInfoA(locale,
2948                                    LOCALE_SABBREVMONTHNAME1
2949                                    + xtime->wMonth - 1,
2950                                    buf, sizeof(buf));
2951                } else if (count == 4) {
2952                   GetLocaleInfoA(locale,
2953                                    LOCALE_SMONTHNAME1
2954                                    + xtime->wMonth - 1,
2955                                    buf, sizeof(buf));
2956                  } else {
2957                   sprintf(buf, dgfmt[count], xtime->wMonth);
2958                }
2959             } else if (type == 'y') {
2960                if (count == 4) {
2961                       sprintf(buf, "%d", xtime->wYear);
2962                } else if (count == 3) {
2963                   strcpy(buf, "yyy");
2964                   WARN("unknown format, c=%c, n=%d\n",  type, count);
2965                  } else {
2966                   sprintf(buf, dgfmt[count], xtime->wYear % 100);
2967                }
2968             } else if (type == 'g') {
2969                if        (count == 2) {
2970                   FIXME("LOCALE_ICALENDARTYPE unimp.\n");
2971                   strcpy(buf, "AD");
2972             } else {
2973                   strcpy(buf, "g");
2974                   WARN("unknown format, c=%c, n=%d\n", type, count);
2975                }
2976             } else if (type == 'h') {
2977                /* gives us hours 1:00 -- 12:00 */
2978                sprintf(buf, dgfmt[count], (xtime->wHour-1)%12 +1);
2979             } else if (type == 'H') {
2980                /* 24-hour time */
2981                sprintf(buf, dgfmt[count], xtime->wHour);
2982             } else if ( type == 'm') {
2983                sprintf(buf, dgfmt[count], xtime->wMinute);
2984             } else if ( type == 's') {
2985                sprintf(buf, dgfmt[count], xtime->wSecond);
2986             } else if (type == 't') {
2987                if        (count == 1) {
2988                   sprintf(buf, "%c", (xtime->wHour < 12) ? 'A' : 'P');
2989                } else if (count == 2) {
2990                   /* sprintf(buf, "%s", (xtime->wHour < 12) ? "AM" : "PM"); */
2991                   GetLocaleInfoA(locale,
2992                                    (xtime->wHour<12)
2993                                    ? LOCALE_S1159 : LOCALE_S2359,
2994                                    buf, sizeof(buf));
2995                }
2996             };
2997
2998             /* we need to check the next char in the format string
2999                again, no matter what happened */
3000             inpos--;
3001
3002             /* add the contents of buf to the output */
3003             buflen = strlen(buf);
3004             if (outpos + buflen < datelen) {
3005                date[outpos] = '\0'; /* for strcat to hook onto */
3006                  strcat(date, buf);
3007                outpos += buflen;
3008             } else {
3009                date[outpos] = '\0';
3010                strncat(date, buf, datelen - outpos);
3011                  date[datelen - 1] = '\0';
3012                  SetLastError(ERROR_INSUFFICIENT_BUFFER);
3013                WARN("insufficient buffer\n");
3014                  return 0;
3015             }
3016
3017             /* reset the variables we used to keep track of this item */
3018             count = 0;
3019             type = '\0';
3020          } else if (format[inpos] == '\0') {
3021             /* we can't check for this at the loop-head, because
3022                that breaks the printing of the last format-item */
3023             date[outpos] = '\0';
3024             break;
3025          } else if (count) {
3026             /* continuing a code for an item */
3027             count +=1;
3028             continue;
3029          } else if (strchr("hHmstyMdg", format[inpos])) {
3030             type = format[inpos];
3031             count = 1;
3032             continue;
3033          } else if (format[inpos] == '\'') {
3034             inquote = 1;
3035             continue;
3036        } else {
3037             date[outpos++] = format[inpos];
3038          }
3039       /* now deal with a possible buffer overflow */
3040       if (outpos >= datelen) {
3041        date[datelen - 1] = '\0';
3042        SetLastError(ERROR_INSUFFICIENT_BUFFER);
3043        return 0;
3044       }
3045    }
3046
3047    if (Overflow) {
3048       SetLastError(ERROR_INSUFFICIENT_BUFFER);
3049    };
3050
3051    /* finish it off with a string terminator */
3052    outpos++;
3053    /* sanity check */
3054    if (outpos > datelen-1) outpos = datelen-1;
3055    date[outpos] = '\0';
3056
3057    TRACE("OLE_GetFormatA returns string '%s', len %d\n",
3058                date, outpos);
3059    return outpos;
3060 }
3061
3062 /******************************************************************************
3063  * OLE_GetFormatW [INTERNAL]
3064  */
3065 static INT OLE_GetFormatW(LCID locale, DWORD flags, DWORD tflags,
3066                             LPSYSTEMTIME xtime,
3067                             LPCWSTR format,
3068                             LPWSTR output, INT outlen)
3069 {
3070    INT   inpos, outpos;
3071    int     count, type=0, inquote;
3072    int     Overflow; /* loop check */
3073    WCHAR   buf[40];
3074    int     buflen=0;
3075    WCHAR   arg0[] = {0}, arg1[] = {'%','d',0};
3076    WCHAR   arg2[] = {'%','0','2','d',0};
3077    WCHAR  *argarr[3];
3078    int     datevars=0, timevars=0;
3079
3080    argarr[0] = arg0;
3081    argarr[1] = arg1;
3082    argarr[2] = arg2;
3083
3084    /* make a debug report */
3085    TRACE("args: 0x%lx, 0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt:%s (at %p), "
3086               "%p with max len %d\n",
3087          locale, flags, tflags,
3088          xtime->wDay, xtime->wHour, xtime->wMinute, xtime->wSecond,
3089          debugstr_w(format), format, output, outlen);
3090
3091    if(outlen == 0) {
3092      FIXME("outlen = 0, returning 255\n");
3093      return 255;
3094    }
3095
3096    /* initialize state variables */
3097    inpos = outpos = 0;
3098    count = 0;
3099    inquote = Overflow = 0;
3100    /* this is really just a sanity check */
3101    output[0] = buf[0] = 0;
3102
3103    /* this loop is the core of the function */
3104    for (inpos = 0; /* we have several break points */ ; inpos++) {
3105       if (inquote) {
3106          if (format[inpos] == (WCHAR) '\'') {
3107             if (format[inpos+1] == '\'') {
3108                inpos++;
3109                output[outpos++] = '\'';
3110             } else {
3111                inquote = 0;
3112                continue;
3113             }
3114          } else if (format[inpos] == 0) {
3115             output[outpos++] = 0;
3116             if (outpos > outlen) Overflow = 1;
3117             break;  /*  normal exit (within a quote) */
3118          } else {
3119             output[outpos++] = format[inpos]; /* copy input */
3120             if (outpos > outlen) {
3121                Overflow = 1;
3122                output[outpos-1] = 0;
3123                break;
3124             }
3125          }
3126       } else if (  (count && (format[inpos] != type))
3127                    || ( (count==4 && type =='y') ||
3128                         (count==4 && type =='M') ||
3129                         (count==4 && type =='d') ||
3130                         (count==2 && type =='g') ||
3131                         (count==2 && type =='h') ||
3132                         (count==2 && type =='H') ||
3133                         (count==2 && type =='m') ||
3134                         (count==2 && type =='s') ||
3135                         (count==2 && type =='t') )  ) {
3136          if        (type == 'd') {
3137             if        (count == 3) {
3138                GetLocaleInfoW(locale,
3139                              LOCALE_SDAYNAME1 + xtime->wDayOfWeek -1,
3140                              buf, sizeof(buf)/sizeof(WCHAR) );
3141             } else if (count == 3) {
3142                GetLocaleInfoW(locale,
3143                                 LOCALE_SABBREVDAYNAME1 +
3144                                 xtime->wDayOfWeek -1,
3145                                 buf, sizeof(buf)/sizeof(WCHAR) );
3146             } else {
3147                wsnprintfW(buf, 5, argarr[count], xtime->wDay );
3148             };
3149          } else if (type == 'M') {
3150             if        (count == 4) {
3151                GetLocaleInfoW(locale,  LOCALE_SMONTHNAME1 +
3152                                 xtime->wMonth -1, buf,
3153                                 sizeof(buf)/sizeof(WCHAR) );
3154             } else if (count == 3) {
3155                GetLocaleInfoW(locale,  LOCALE_SABBREVMONTHNAME1 +
3156                                 xtime->wMonth -1, buf,
3157                                 sizeof(buf)/sizeof(WCHAR) );
3158             } else {
3159                wsnprintfW(buf, 5, argarr[count], xtime->wMonth);
3160             }
3161          } else if (type == 'y') {
3162             if        (count == 4) {
3163                wsnprintfW(buf, 6, argarr[1] /* "%d" */,
3164                          xtime->wYear);
3165             } else if (count == 3) {
3166                lstrcpynAtoW(buf, "yyy", 5);
3167             } else {
3168                wsnprintfW(buf, 6, argarr[count],
3169                             xtime->wYear % 100);
3170             }
3171          } else if (type == 'g') {
3172             if        (count == 2) {
3173                FIXME("LOCALE_ICALENDARTYPE unimplemented\n");
3174                lstrcpynAtoW(buf, "AD", 5);
3175             } else {
3176                /* Win API sez we copy it verbatim */
3177                lstrcpynAtoW(buf, "g", 5);
3178             }
3179          } else if (type == 'h') {
3180             /* hours 1:00-12:00 --- is this right? */
3181             wsnprintfW(buf, 5, argarr[count],
3182                          (xtime->wHour-1)%12 +1);
3183          } else if (type == 'H') {
3184             wsnprintfW(buf, 5, argarr[count],
3185                          xtime->wHour);
3186          } else if (type == 'm' ) {
3187             wsnprintfW(buf, 5, argarr[count],
3188                          xtime->wMinute);
3189          } else if (type == 's' ) {
3190             wsnprintfW(buf, 5, argarr[count],
3191                          xtime->wSecond);
3192          } else if (type == 't') {
3193             GetLocaleInfoW(locale, (xtime->wHour < 12) ?
3194                              LOCALE_S1159 : LOCALE_S2359,
3195                              buf, sizeof(buf) );
3196             if        (count == 1) {
3197                buf[1] = 0;
3198             }
3199 }
3200
3201          /* no matter what happened,  we need to check this next
3202             character the next time we loop through */
3203          inpos--;
3204
3205          /* cat buf onto the output */
3206          outlen = lstrlenW(buf);
3207          if (outpos + buflen < outlen) {
3208             lstrcpyW( output + outpos, buf );
3209             outpos += buflen;
3210          } else {
3211             lstrcpynW( output + outpos, buf, outlen - outpos );
3212             Overflow = 1;
3213             break; /* Abnormal exit */
3214          }
3215
3216          /* reset the variables we used this time */
3217          count = 0;
3218          type = '\0';
3219       } else if (format[inpos] == 0) {
3220          /* we can't check for this at the beginning,  because that
3221          would keep us from printing a format spec that ended the
3222          string */
3223          output[outpos] = 0;
3224          break;  /*  NORMAL EXIT  */
3225       } else if (count) {
3226          /* how we keep track of the middle of a format spec */
3227          count++;
3228          continue;
3229       } else if ( (datevars && (format[inpos]=='d' ||
3230                                 format[inpos]=='M' ||
3231                                 format[inpos]=='y' ||
3232                                 format[inpos]=='g')  ) ||
3233                   (timevars && (format[inpos]=='H' ||
3234                                 format[inpos]=='h' ||
3235                                 format[inpos]=='m' ||
3236                                 format[inpos]=='s' ||
3237                                 format[inpos]=='t') )    ) {
3238          type = format[inpos];
3239          count = 1;
3240          continue;
3241       } else if (format[inpos] == '\'') {
3242          inquote = 1;
3243          continue;
3244       } else {
3245          /* unquoted literals */
3246          output[outpos++] = format[inpos];
3247       }
3248    }
3249
3250    if (Overflow) {
3251       SetLastError(ERROR_INSUFFICIENT_BUFFER);
3252       WARN(" buffer overflow\n");
3253    };
3254
3255    /* final string terminator and sanity check */
3256    outpos++;
3257    if (outpos > outlen-1) outpos = outlen-1;
3258    output[outpos] = '0';
3259
3260    TRACE(" returning %s\n", debugstr_w(output));
3261
3262    return (!Overflow) ? outlen : 0;
3263
3264 }
3265
3266
3267 /******************************************************************************
3268  *              GetDateFormatA  [KERNEL32.310]
3269  * Makes an ASCII string of the date
3270  *
3271  * This function uses format to format the date,  or,  if format
3272  * is NULL, uses the default for the locale.  format is a string
3273  * of literal fields and characters as follows:
3274  *
3275  * - d    single-digit (no leading zero) day (of month)
3276  * - dd   two-digit day (of month)
3277  * - ddd  short day-of-week name
3278  * - dddd long day-of-week name
3279  * - M    single-digit month
3280  * - MM   two-digit month
3281  * - MMM  short month name
3282  * - MMMM full month name
3283  * - y    two-digit year, no leading 0
3284  * - yy   two-digit year
3285  * - yyyy four-digit year
3286  * - gg   era string
3287  *
3288  */
3289 INT WINAPI GetDateFormatA(LCID locale,DWORD flags,
3290                               LPSYSTEMTIME xtime,
3291                               LPCSTR format, LPSTR date,INT datelen)
3292 {
3293
3294   char format_buf[40];
3295   LPCSTR thisformat;
3296   SYSTEMTIME t;
3297   LPSYSTEMTIME thistime;
3298   LCID thislocale;
3299   INT ret;
3300
3301   TRACE("(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",
3302               locale,flags,xtime,format,date,datelen);
3303
3304   if (!locale) {
3305      locale = LOCALE_SYSTEM_DEFAULT;
3306      };
3307
3308   if (locale == LOCALE_SYSTEM_DEFAULT) {
3309      thislocale = GetSystemDefaultLCID();
3310   } else if (locale == LOCALE_USER_DEFAULT) {
3311      thislocale = GetUserDefaultLCID();
3312   } else {
3313      thislocale = locale;
3314    };
3315
3316   if (xtime == NULL) {
3317      GetSystemTime(&t);
3318      thistime = &t;
3319   } else {
3320      thistime = xtime;
3321   };
3322
3323   if (format == NULL) {
3324      GetLocaleInfoA(thislocale, ((flags&DATE_LONGDATE)
3325                                    ? LOCALE_SLONGDATE
3326                                    : LOCALE_SSHORTDATE),
3327                       format_buf, sizeof(format_buf));
3328      thisformat = format_buf;
3329   } else {
3330      thisformat = format;
3331   };
3332
3333
3334   ret = OLE_GetFormatA(thislocale, flags, 0, thistime, thisformat,
3335                        date, datelen);
3336
3337
3338    TRACE(
3339                "GetDateFormatA() returning %d, with data=%s\n",
3340                ret, date);
3341   return ret;
3342 }
3343
3344 /******************************************************************************
3345  *              GetDateFormatW  [KERNEL32.311]
3346  * Makes a Unicode string of the date
3347  *
3348  * Acts the same as GetDateFormatA(),  except that it's Unicode.
3349  * Accepts & returns sizes as counts of Unicode characters.
3350  *
3351  */
3352 INT WINAPI GetDateFormatW(LCID locale,DWORD flags,
3353                               LPSYSTEMTIME xtime,
3354                               LPCWSTR format,
3355                               LPWSTR date, INT datelen)
3356 {
3357    unsigned short datearr[] = {'1','9','9','4','-','1','-','1',0};
3358
3359    FIXME("STUB (should call OLE_GetFormatW)\n");
3360    lstrcpynW(date, datearr, datelen);
3361    return (  datelen < 9) ? datelen : 9;
3362
3363
3364 }
3365
3366 /**************************************************************************
3367  *              EnumDateFormatsA        (KERNEL32.198)
3368  */
3369 BOOL WINAPI EnumDateFormatsA(
3370   DATEFMT_ENUMPROCA lpDateFmtEnumProc, LCID Locale,  DWORD dwFlags)
3371 {
3372   LCID Loc = GetUserDefaultLCID();
3373   if(!lpDateFmtEnumProc)
3374     {
3375       SetLastError(ERROR_INVALID_PARAMETER);
3376       return FALSE;
3377     }
3378
3379   switch( Loc )
3380  {
3381
3382    case 0x00000407:  /* (Loc,"de_DE") */
3383    {
3384     switch(dwFlags)
3385     {
3386       case DATE_SHORTDATE:
3387         if(!(*lpDateFmtEnumProc)("dd.MM.yy")) return TRUE;
3388         if(!(*lpDateFmtEnumProc)("d.M.yyyy")) return TRUE;
3389         if(!(*lpDateFmtEnumProc)("d.MM.yy")) return TRUE;
3390         if(!(*lpDateFmtEnumProc)("d.M.yy")) return TRUE;
3391         return TRUE;
3392       case DATE_LONGDATE:
3393         if(!(*lpDateFmtEnumProc)("dddd,d. MMMM yyyy")) return TRUE;
3394         if(!(*lpDateFmtEnumProc)("d. MMMM yyyy")) return TRUE;
3395         if(!(*lpDateFmtEnumProc)("d. MMM yyyy")) return TRUE;
3396         return TRUE;
3397       default:
3398         FIXME("Unknown date format (%ld)\n", dwFlags);
3399         SetLastError(ERROR_INVALID_PARAMETER);
3400         return FALSE;
3401      }
3402    }
3403
3404    case 0x0000040c:  /* (Loc,"fr_FR") */
3405    {
3406     switch(dwFlags)
3407     {
3408       case DATE_SHORTDATE:
3409         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3410         if(!(*lpDateFmtEnumProc)("dd.MM.yy")) return TRUE;
3411         if(!(*lpDateFmtEnumProc)("dd-MM-yy")) return TRUE;
3412         if(!(*lpDateFmtEnumProc)("dd/MM/yyyy")) return TRUE;
3413         return TRUE;
3414       case DATE_LONGDATE:
3415         if(!(*lpDateFmtEnumProc)("dddd d MMMM yyyy")) return TRUE;
3416         if(!(*lpDateFmtEnumProc)("d MMM yy")) return TRUE;
3417         if(!(*lpDateFmtEnumProc)("d MMMM yyyy")) return TRUE;
3418         return TRUE;
3419       default:
3420         FIXME("Unknown date format (%ld)\n", dwFlags);
3421         SetLastError(ERROR_INVALID_PARAMETER);
3422         return FALSE;
3423      }
3424    }
3425
3426    case 0x00000c0c:  /* (Loc,"fr_CA") */
3427    {
3428     switch(dwFlags)
3429     {
3430       case DATE_SHORTDATE:
3431         if(!(*lpDateFmtEnumProc)("yy-MM-dd")) return TRUE;
3432         if(!(*lpDateFmtEnumProc)("dd-MM-yy")) return TRUE;
3433         if(!(*lpDateFmtEnumProc)("yy MM dd")) return TRUE;
3434         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3435         return TRUE;
3436       case DATE_LONGDATE:
3437         if(!(*lpDateFmtEnumProc)("d MMMM, yyyy")) return TRUE;
3438         if(!(*lpDateFmtEnumProc)("d MMM yyyy")) return TRUE;
3439         return TRUE;
3440       default:
3441         FIXME("Unknown date format (%ld)\n", dwFlags);
3442         SetLastError(ERROR_INVALID_PARAMETER);
3443         return FALSE;
3444      }
3445    }
3446
3447    case 0x00000809:  /* (Loc,"en_UK") */
3448   {
3449    switch(dwFlags)
3450     {
3451       case DATE_SHORTDATE:
3452         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3453         if(!(*lpDateFmtEnumProc)("dd/MM/yyyy")) return TRUE;
3454         if(!(*lpDateFmtEnumProc)("d/M/yy")) return TRUE;
3455         if(!(*lpDateFmtEnumProc)("d.M.yy")) return TRUE;
3456         return TRUE;
3457       case DATE_LONGDATE:
3458         if(!(*lpDateFmtEnumProc)("dd MMMM yyyy")) return TRUE;
3459         if(!(*lpDateFmtEnumProc)("d MMMM yyyy")) return TRUE;
3460         return TRUE;
3461       default:
3462         FIXME("Unknown date format (%ld)\n", dwFlags);
3463         SetLastError(ERROR_INVALID_PARAMETER);
3464         return FALSE;
3465     }
3466   }
3467
3468    case 0x00000c09:  /* (Loc,"en_AU") */
3469   {
3470    switch(dwFlags)
3471     {
3472       case DATE_SHORTDATE:
3473         if(!(*lpDateFmtEnumProc)("d/MM/yy")) return TRUE;
3474         if(!(*lpDateFmtEnumProc)("d/M/yy")) return TRUE;
3475         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3476         return TRUE;
3477       case DATE_LONGDATE:
3478         if(!(*lpDateFmtEnumProc)("dddd,d MMMM yyyy")) return TRUE;
3479         if(!(*lpDateFmtEnumProc)("d MMMM yyyy")) return TRUE;
3480         return TRUE;
3481       default:
3482         FIXME("Unknown date format (%ld)\n", dwFlags);
3483         SetLastError(ERROR_INVALID_PARAMETER);
3484         return FALSE;
3485     }
3486   }
3487
3488    case 0x00001009:  /* (Loc,"en_CA") */
3489   {
3490    switch(dwFlags)
3491     {
3492       case DATE_SHORTDATE:
3493         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3494         if(!(*lpDateFmtEnumProc)("d/M/yy")) return TRUE;
3495         if(!(*lpDateFmtEnumProc)("yy-MM-dd")) return TRUE;
3496         if(!(*lpDateFmtEnumProc)("M/dd/yy")) return TRUE;
3497         return TRUE;
3498       case DATE_LONGDATE:
3499         if(!(*lpDateFmtEnumProc)("d-MMM-yy")) return TRUE;
3500         if(!(*lpDateFmtEnumProc)("MMMM d, yyyy")) return TRUE;
3501         return TRUE;
3502       default:
3503         FIXME("Unknown date format (%ld)\n", dwFlags);
3504         SetLastError(ERROR_INVALID_PARAMETER);
3505         return FALSE;
3506     }
3507   }
3508
3509    case 0x00001409:  /* (Loc,"en_NZ") */
3510   {
3511    switch(dwFlags)
3512     {
3513       case DATE_SHORTDATE:
3514         if(!(*lpDateFmtEnumProc)("d/MM/yy")) return TRUE;
3515         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3516         if(!(*lpDateFmtEnumProc)("d.MM.yy")) return TRUE;
3517         return TRUE;
3518       case DATE_LONGDATE:
3519         if(!(*lpDateFmtEnumProc)("d MMMM yyyy")) return TRUE;
3520         if(!(*lpDateFmtEnumProc)("dddd, d MMMM yyyy")) return TRUE;
3521         return TRUE;
3522       default:
3523         FIXME("Unknown date format (%ld)\n", dwFlags);
3524         SetLastError(ERROR_INVALID_PARAMETER);
3525         return FALSE;
3526     }
3527   }
3528
3529    case 0x00001809:  /* (Loc,"en_IE") */
3530   {
3531    switch(dwFlags)
3532     {
3533       case DATE_SHORTDATE:
3534         if(!(*lpDateFmtEnumProc)("dd/MM/yy")) return TRUE;
3535         if(!(*lpDateFmtEnumProc)("d/M/yy")) return TRUE;
3536         if(!(*lpDateFmtEnumProc)("d.M.yy")) return TRUE;
3537         return TRUE;
3538       case DATE_LONGDATE:
3539         if(!(*lpDateFmtEnumProc)("dd MMMM yyyy")) return TRUE;
3540         if(!(*lpDateFmtEnumProc)("d MMMM yyyy")) return TRUE;
3541         return TRUE;
3542       default:
3543         FIXME("Unknown date format (%ld)\n", dwFlags);
3544         SetLastError(ERROR_INVALID_PARAMETER);
3545         return FALSE;
3546     }
3547   }
3548
3549    case 0x00001c09:  /* (Loc,"en_ZA") */
3550   {
3551    switch(dwFlags)
3552     {
3553       case DATE_SHORTDATE:
3554         if(!(*lpDateFmtEnumProc)("yy/MM/dd")) return TRUE;
3555         return TRUE;
3556       case DATE_LONGDATE:
3557         if(!(*lpDateFmtEnumProc)("dd MMMM yyyy")) return TRUE;
3558         return TRUE;
3559       default:
3560         FIXME("Unknown date format (%ld)\n", dwFlags);
3561         SetLastError(ERROR_INVALID_PARAMETER);
3562         return FALSE;
3563     }
3564   }
3565
3566    case 0x00002009:  /* (Loc,"en_JM") */
3567   {
3568    switch(dwFlags)
3569     {
3570       case DATE_SHORTDATE:
3571         if(!(*lpDateFmtEnumProc)("dd/MM/yyyy")) return TRUE;
3572         return TRUE;
3573       case DATE_LONGDATE:
3574         if(!(*lpDateFmtEnumProc)("dddd,MMMM dd,yyyy")) return TRUE;
3575         if(!(*lpDateFmtEnumProc)("MMMM dd,yyyy")) return TRUE;
3576         if(!(*lpDateFmtEnumProc)("dddd,dd MMMM,yyyy")) return TRUE;
3577         if(!(*lpDateFmtEnumProc)("dd MMMM,yyyy")) return TRUE;
3578         return TRUE;
3579       default:
3580         FIXME("Unknown date format (%ld)\n", dwFlags);
3581         SetLastError(ERROR_INVALID_PARAMETER);
3582         return FALSE;
3583     }
3584   }
3585
3586    case 0x00002809:  /* (Loc,"en_BZ") */
3587    case 0x00002c09:  /* (Loc,"en_TT") */
3588   {
3589    switch(dwFlags)
3590     {
3591       case DATE_SHORTDATE:
3592         if(!(*lpDateFmtEnumProc)("dd/MM/yyyy")) return TRUE;
3593         return TRUE;
3594       case DATE_LONGDATE:
3595         if(!(*lpDateFmtEnumProc)("dddd,dd MMMM yyyy")) return TRUE;
3596         return TRUE;
3597       default:
3598         FIXME("Unknown date format (%ld)\n", dwFlags);
3599         SetLastError(ERROR_INVALID_PARAMETER);
3600         return FALSE;
3601     }
3602   }
3603
3604    default:  /* default to US English "en_US" */
3605   {
3606    switch(dwFlags)
3607     {
3608       case DATE_SHORTDATE:
3609         if(!(*lpDateFmtEnumProc)("M/d/yy")) return TRUE;
3610         if(!(*lpDateFmtEnumProc)("M/d/yyyy")) return TRUE;
3611         if(!(*lpDateFmtEnumProc)("MM/dd/yy")) return TRUE;
3612         if(!(*lpDateFmtEnumProc)("MM/dd/yyyy")) return TRUE;
3613         if(!(*lpDateFmtEnumProc)("yy/MM/dd")) return TRUE;
3614         if(!(*lpDateFmtEnumProc)("dd-MMM-yy")) return TRUE;
3615         return TRUE;
3616       case DATE_LONGDATE:
3617         if(!(*lpDateFmtEnumProc)("dddd, MMMM dd, yyyy")) return TRUE;
3618         if(!(*lpDateFmtEnumProc)("MMMM dd, yyyy")) return TRUE;
3619         if(!(*lpDateFmtEnumProc)("dddd, dd MMMM, yyyy")) return TRUE;
3620         if(!(*lpDateFmtEnumProc)("dd MMMM, yyyy")) return TRUE;
3621         return TRUE;
3622       default:
3623         FIXME("Unknown date format (%ld)\n", dwFlags);
3624         SetLastError(ERROR_INVALID_PARAMETER);
3625         return FALSE;
3626     }
3627   }
3628  }
3629 }
3630
3631 /**************************************************************************
3632  *              EnumDateFormatsW        (KERNEL32.199)
3633  */
3634 BOOL WINAPI EnumDateFormatsW(
3635   DATEFMT_ENUMPROCW lpDateFmtEnumProc, LCID Locale, DWORD dwFlags)
3636 {
3637   FIXME("(%p, %ld, %ld): stub\n", lpDateFmtEnumProc, Locale, dwFlags);
3638   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3639   return FALSE;
3640 }
3641
3642 /**************************************************************************
3643  *              EnumTimeFormatsA        (KERNEL32.210)
3644  */
3645 BOOL WINAPI EnumTimeFormatsA(
3646   TIMEFMT_ENUMPROCA lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags)
3647 {
3648   LCID Loc = GetUserDefaultLCID();
3649   if(!lpTimeFmtEnumProc)
3650     {
3651       SetLastError(ERROR_INVALID_PARAMETER);
3652       return FALSE;
3653     }
3654   if(dwFlags)
3655     {
3656       FIXME("Unknown time format (%ld)\n", dwFlags);
3657     }
3658
3659   switch( Loc )
3660  {
3661    case 0x00000407:  /* (Loc,"de_DE") */
3662    {
3663     if(!(*lpTimeFmtEnumProc)("HH.mm")) return TRUE;
3664     if(!(*lpTimeFmtEnumProc)("HH:mm:ss")) return TRUE;
3665     if(!(*lpTimeFmtEnumProc)("H:mm:ss")) return TRUE;
3666     if(!(*lpTimeFmtEnumProc)("H.mm")) return TRUE;
3667     if(!(*lpTimeFmtEnumProc)("H.mm'Uhr'")) return TRUE;
3668     return TRUE;
3669    }
3670
3671    case 0x0000040c:  /* (Loc,"fr_FR") */
3672    case 0x00000c0c:  /* (Loc,"fr_CA") */
3673    {
3674     if(!(*lpTimeFmtEnumProc)("H:mm")) return TRUE;
3675     if(!(*lpTimeFmtEnumProc)("HH:mm:ss")) return TRUE;
3676     if(!(*lpTimeFmtEnumProc)("H:mm:ss")) return TRUE;
3677     if(!(*lpTimeFmtEnumProc)("HH.mm")) return TRUE;
3678     if(!(*lpTimeFmtEnumProc)("HH'h'mm")) return TRUE;
3679     return TRUE;
3680    }
3681
3682    case 0x00000809:  /* (Loc,"en_UK") */
3683    case 0x00000c09:  /* (Loc,"en_AU") */
3684    case 0x00001409:  /* (Loc,"en_NZ") */
3685    case 0x00001809:  /* (Loc,"en_IE") */
3686    {
3687     if(!(*lpTimeFmtEnumProc)("h:mm:ss tt")) return TRUE;
3688     if(!(*lpTimeFmtEnumProc)("HH:mm:ss")) return TRUE;
3689     if(!(*lpTimeFmtEnumProc)("H:mm:ss")) return TRUE;
3690     return TRUE;
3691    }
3692
3693    case 0x00001c09:  /* (Loc,"en_ZA") */
3694    case 0x00002809:  /* (Loc,"en_BZ") */
3695    case 0x00002c09:  /* (Loc,"en_TT") */
3696    {
3697     if(!(*lpTimeFmtEnumProc)("h:mm:ss tt")) return TRUE;
3698     if(!(*lpTimeFmtEnumProc)("hh:mm:ss tt")) return TRUE;
3699     return TRUE;
3700    }
3701
3702    default:  /* default to US style "en_US" */
3703    {
3704     if(!(*lpTimeFmtEnumProc)("h:mm:ss tt")) return TRUE;
3705     if(!(*lpTimeFmtEnumProc)("hh:mm:ss tt")) return TRUE;
3706     if(!(*lpTimeFmtEnumProc)("H:mm:ss")) return TRUE;
3707     if(!(*lpTimeFmtEnumProc)("HH:mm:ss")) return TRUE;
3708     return TRUE;
3709    }
3710  }
3711 }
3712
3713 /**************************************************************************
3714  *              EnumTimeFormatsW        (KERNEL32.211)
3715  */
3716 BOOL WINAPI EnumTimeFormatsW(
3717   TIMEFMT_ENUMPROCW lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags)
3718 {
3719   FIXME("(%p,%ld,%ld): stub\n", lpTimeFmtEnumProc, Locale, dwFlags);
3720   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3721   return FALSE;
3722 }
3723
3724 /**************************************************************************
3725  *           This function is used just locally !
3726  *  Description: Inverts a string.
3727  */
3728 static void OLE_InvertString(char* string)
3729 {
3730     char    sTmpArray[128];
3731     INT     counter, i = 0;
3732
3733     for (counter = strlen(string); counter > 0; counter--)
3734     {
3735         memcpy(sTmpArray + i, string + counter-1, 1);
3736         i++;
3737     }
3738     memcpy(sTmpArray + i, "\0", 1);
3739     strcpy(string, sTmpArray);
3740 }
3741
3742 /***************************************************************************************
3743  *           This function is used just locally !
3744  *  Description: Test if the given string (psNumber) is valid or not.
3745  *               The valid characters are the following:
3746  *               - Characters '0' through '9'.
3747  *               - One decimal point (dot) if the number is a floating-point value.
3748  *               - A minus sign in the first character position if the number is
3749  *                 a negative value.
3750  *              If the function succeeds, psBefore/psAfter will point to the string
3751  *              on the right/left of the decimal symbol. pbNegative indicates if the
3752  *              number is negative.
3753  */
3754 static INT OLE_GetNumberComponents(char* pInput, char* psBefore, char* psAfter, BOOL* pbNegative)
3755 {
3756 char    sNumberSet[] = "0123456789";
3757 BOOL    bInDecimal = FALSE;
3758
3759         /* Test if we do have a minus sign */
3760         if ( *pInput == '-' )
3761         {
3762                 *pbNegative = TRUE;
3763                 pInput++; /* Jump to the next character. */
3764         }
3765
3766         while(*pInput != '\0')
3767         {
3768                 /* Do we have a valid numeric character */
3769                 if ( strchr(sNumberSet, *pInput) != NULL )
3770                 {
3771                         if (bInDecimal == TRUE)
3772                 *psAfter++ = *pInput;
3773                         else
3774                 *psBefore++ = *pInput;
3775                 }
3776                 else
3777                 {
3778                         /* Is this a decimal point (dot) */
3779                         if ( *pInput == '.' )
3780                         {
3781                                 /* Is it the first time we find it */
3782                                 if ((bInDecimal == FALSE))
3783                                         bInDecimal = TRUE;
3784                                 else
3785                                         return -1; /* ERROR: Invalid parameter */
3786                         }
3787                         else
3788                         {
3789                                 /* It's neither a numeric character, nor a decimal point.
3790                                  * Thus, return an error.
3791                  */
3792                                 return -1;
3793                         }
3794                 }
3795         pInput++;
3796         }
3797
3798         /* Add an End of Line character to the output buffers */
3799         *psBefore = '\0';
3800         *psAfter = '\0';
3801
3802         return 0;
3803 }
3804
3805 /**************************************************************************
3806  *           This function is used just locally !
3807  *  Description: A number could be formatted using different numbers
3808  *               of "digits in group" (example: 4;3;2;0).
3809  *               The first parameter of this function is an array
3810  *               containing the rule to be used. It's format is the following:
3811  *               |NDG|DG1|DG2|...|0|
3812  *               where NDG is the number of used "digits in group" and DG1, DG2,
3813  *               are the corresponding "digits in group".
3814  *               Thus, this function returns the grouping value in the array
3815  *               pointed by the second parameter.
3816  */
3817 static INT OLE_GetGrouping(char* sRule, INT index)
3818 {
3819     char    sData[2], sRuleSize[2];
3820     INT     nData, nRuleSize;
3821
3822     memcpy(sRuleSize, sRule, 1);
3823     memcpy(sRuleSize+1, "\0", 1);
3824     nRuleSize = atoi(sRuleSize);
3825
3826     if (index > 0 && index < nRuleSize)
3827     {
3828         memcpy(sData, sRule+index, 1);
3829         memcpy(sData+1, "\0", 1);
3830         nData = atoi(sData);
3831     }
3832
3833     else
3834     {
3835         memcpy(sData, sRule+nRuleSize-1, 1);
3836         memcpy(sData+1, "\0", 1);
3837         nData = atoi(sData);
3838     }
3839
3840     return nData;
3841 }
3842
3843 /**************************************************************************
3844  *              GetNumberFormatA        (KERNEL32.355)
3845  */
3846 INT WINAPI GetNumberFormatA(LCID locale, DWORD dwflags,
3847                                LPCSTR lpvalue,   const NUMBERFMTA * lpFormat,
3848                                LPSTR lpNumberStr, int cchNumber)
3849 {
3850     char   sNumberDigits[3], sDecimalSymbol[5], sDigitsInGroup[11], sDigitGroupSymbol[5], sILZero[2];
3851     INT    nNumberDigits, nNumberDecimal, i, j, nCounter, nStep, nRuleIndex, nGrouping, nDigits, retVal, nLZ;
3852     char   sNumber[128], sDestination[128], sDigitsAfterDecimal[10], sDigitsBeforeDecimal[128];
3853     char   sRule[10], sSemiColumn[]=";", sBuffer[5], sNegNumber[2];
3854     char   *pStr = NULL, *pTmpStr = NULL;
3855     LCID   systemDefaultLCID;
3856     BOOL   bNegative = FALSE;
3857     enum   Operations
3858     {
3859         USE_PARAMETER,
3860         USE_LOCALEINFO,
3861         USE_SYSTEMDEFAULT,
3862         RETURN_ERROR
3863     } used_operation;
3864
3865     strncpy(sNumber, lpvalue, 128);
3866     sNumber[127] = '\0';
3867
3868     /* Make sure we have a valid input string, get the number
3869      * of digits before and after the decimal symbol, and check
3870      * if this is a negative number.
3871      */
3872     if ( OLE_GetNumberComponents(sNumber, sDigitsBeforeDecimal, sDigitsAfterDecimal, &bNegative) != -1)
3873     {
3874         nNumberDecimal = strlen(sDigitsBeforeDecimal);
3875         nDigits = strlen(sDigitsAfterDecimal);
3876     }
3877     else
3878     {
3879         SetLastError(ERROR_INVALID_PARAMETER);
3880         return 0;
3881     }
3882
3883     /* Which source will we use to format the string */
3884     used_operation = RETURN_ERROR;
3885     if (lpFormat != NULL)
3886     {
3887         if (dwflags == 0)
3888             used_operation = USE_PARAMETER;
3889     }
3890     else
3891     {
3892         if (dwflags & LOCALE_NOUSEROVERRIDE)
3893             used_operation = USE_LOCALEINFO;
3894         else
3895             used_operation = USE_SYSTEMDEFAULT;
3896     }
3897
3898     /* Load the fields we need */
3899     switch(used_operation)
3900     {
3901     case USE_LOCALEINFO:
3902         GetLocaleInfoA(locale, LOCALE_IDIGITS, sNumberDigits, sizeof(sNumberDigits));
3903         GetLocaleInfoA(locale, LOCALE_SDECIMAL, sDecimalSymbol, sizeof(sDecimalSymbol));
3904         GetLocaleInfoA(locale, LOCALE_SGROUPING, sDigitsInGroup, sizeof(sDigitsInGroup));
3905         GetLocaleInfoA(locale, LOCALE_STHOUSAND, sDigitGroupSymbol, sizeof(sDigitGroupSymbol));
3906         GetLocaleInfoA(locale, LOCALE_ILZERO, sILZero, sizeof(sILZero));
3907         GetLocaleInfoA(locale, LOCALE_INEGNUMBER, sNegNumber, sizeof(sNegNumber));
3908         break;
3909     case USE_PARAMETER:
3910         sprintf(sNumberDigits, "%d",lpFormat->NumDigits);
3911         strcpy(sDecimalSymbol, lpFormat->lpDecimalSep);
3912         sprintf(sDigitsInGroup, "%d;0",lpFormat->Grouping);
3913         strcpy(sDigitGroupSymbol, lpFormat->lpThousandSep);
3914         sprintf(sILZero, "%d",lpFormat->LeadingZero);
3915         sprintf(sNegNumber, "%d",lpFormat->NegativeOrder);
3916         break;
3917     case USE_SYSTEMDEFAULT:
3918         systemDefaultLCID = GetSystemDefaultLCID();
3919         GetLocaleInfoA(systemDefaultLCID, LOCALE_IDIGITS, sNumberDigits, sizeof(sNumberDigits));
3920         GetLocaleInfoA(systemDefaultLCID, LOCALE_SDECIMAL, sDecimalSymbol, sizeof(sDecimalSymbol));
3921         GetLocaleInfoA(systemDefaultLCID, LOCALE_SGROUPING, sDigitsInGroup, sizeof(sDigitsInGroup));
3922         GetLocaleInfoA(systemDefaultLCID, LOCALE_STHOUSAND, sDigitGroupSymbol, sizeof(sDigitGroupSymbol));
3923         GetLocaleInfoA(systemDefaultLCID, LOCALE_ILZERO, sILZero, sizeof(sILZero));
3924         GetLocaleInfoA(systemDefaultLCID, LOCALE_INEGNUMBER, sNegNumber, sizeof(sNegNumber));
3925         break;
3926     default:
3927         SetLastError(ERROR_INVALID_PARAMETER);
3928         return 0;
3929     }
3930
3931     nNumberDigits = atoi(sNumberDigits);
3932
3933     /* Remove the ";" */
3934     i=0;
3935     j = 1;
3936     for (nCounter=0; nCounter<strlen(sDigitsInGroup); nCounter++)
3937     {
3938         if ( memcmp(sDigitsInGroup + nCounter, sSemiColumn, 1) != 0 )
3939         {
3940             memcpy(sRule + j, sDigitsInGroup + nCounter, 1);
3941             i++;
3942             j++;
3943         }
3944     }
3945     sprintf(sBuffer, "%d", i);
3946     memcpy(sRule, sBuffer, 1); /* Number of digits in the groups ( used by OLE_GetGrouping() ) */
3947     memcpy(sRule + j, "\0", 1);
3948
3949     /* First, format the digits before the decimal. */
3950     if ((nNumberDecimal>0) && (atoi(sDigitsBeforeDecimal) != 0))
3951     {
3952         /* Working on an inverted string is easier ! */
3953         OLE_InvertString(sDigitsBeforeDecimal);
3954
3955         nStep = nCounter = i = j = 0;
3956         nRuleIndex = 1;
3957         nGrouping = OLE_GetGrouping(sRule, nRuleIndex);
3958
3959         /* Here, we will loop until we reach the end of the string.
3960          * An internal counter (j) is used in order to know when to
3961          * insert the "digit group symbol".
3962          */
3963         while (nNumberDecimal > 0)
3964         {
3965             i = nCounter + nStep;
3966             memcpy(sDestination + i, sDigitsBeforeDecimal + nCounter, 1);
3967             nCounter++;
3968             j++;
3969             if (j >= nGrouping)
3970             {
3971                 j = 0;
3972                 if (nRuleIndex < sRule[0])
3973                     nRuleIndex++;
3974                 nGrouping = OLE_GetGrouping(sRule, nRuleIndex);
3975                 memcpy(sDestination + i+1, sDigitGroupSymbol, strlen(sDigitGroupSymbol));
3976                 nStep+= strlen(sDigitGroupSymbol);
3977             }
3978
3979             nNumberDecimal--;
3980         }
3981
3982         memcpy(sDestination + i+1, "\0", 1);
3983         /* Get the string in the right order ! */
3984         OLE_InvertString(sDestination);
3985      }
3986      else
3987      {
3988         nLZ = atoi(sILZero);
3989         if (nLZ != 0)
3990         {
3991             /* Use 0.xxx instead of .xxx */
3992             memcpy(sDestination, "0", 1);
3993             memcpy(sDestination+1, "\0", 1);
3994         }
3995         else
3996             memcpy(sDestination, "\0", 1);
3997
3998      }
3999
4000     /* Second, format the digits after the decimal. */
4001     j = 0;
4002     nCounter = nNumberDigits;
4003     if ( (nDigits>0) && (pStr = strstr (sNumber, ".")) )
4004     {
4005         i = strlen(sNumber) - strlen(pStr) + 1;
4006         strncpy ( sDigitsAfterDecimal, sNumber + i, nNumberDigits);
4007         j = strlen(sDigitsAfterDecimal);
4008         if (j < nNumberDigits)
4009             nCounter = nNumberDigits-j;
4010     }
4011     for (i=0;i<nCounter;i++)
4012          memcpy(sDigitsAfterDecimal+i+j, "0", 1);
4013     memcpy(sDigitsAfterDecimal + nNumberDigits, "\0", 1);
4014
4015     i = strlen(sDestination);
4016     j = strlen(sDigitsAfterDecimal);
4017     /* Finally, construct the resulting formatted string. */
4018
4019     for (nCounter=0; nCounter<i; nCounter++)
4020         memcpy(sNumber + nCounter, sDestination + nCounter, 1);
4021
4022     memcpy(sNumber + nCounter, sDecimalSymbol, strlen(sDecimalSymbol));
4023
4024     for (i=0; i<j; i++)
4025         memcpy(sNumber + nCounter+i+strlen(sDecimalSymbol), sDigitsAfterDecimal + i, 1);
4026     memcpy(sNumber + nCounter+i+strlen(sDecimalSymbol), "\0", 1);
4027
4028     /* Is it a negative number */
4029     if (bNegative == TRUE)
4030     {
4031         i = atoi(sNegNumber);
4032         pStr = sDestination;
4033         pTmpStr = sNumber;
4034         switch (i)
4035         {
4036         case 0:
4037             *pStr++ = '(';
4038             while (*sNumber != '\0')
4039                 *pStr++ =  *pTmpStr++;
4040             *pStr++ = ')';
4041             break;
4042         case 1:
4043             *pStr++ = '-';
4044             while (*pTmpStr != '\0')
4045                 *pStr++ =  *pTmpStr++;
4046             break;
4047         case 2:
4048             *pStr++ = '-';
4049             *pStr++ = ' ';
4050             while (*pTmpStr != '\0')
4051                 *pStr++ =  *pTmpStr++;
4052             break;
4053         case 3:
4054             while (*pTmpStr != '\0')
4055                 *pStr++ =  *pTmpStr++;
4056             *pStr++ = '-';
4057             break;
4058         case 4:
4059             while (*pTmpStr != '\0')
4060                 *pStr++ =  *pTmpStr++;
4061             *pStr++ = ' ';
4062             *pStr++ = '-';
4063             break;
4064         default:
4065             while (*pTmpStr != '\0')
4066                 *pStr++ =  *pTmpStr++;
4067             break;
4068         }
4069     }
4070     else
4071         strcpy(sDestination, sNumber);
4072
4073     /* If cchNumber is zero, then returns the number of bytes or characters
4074      * required to hold the formatted number string
4075      */
4076     if (cchNumber==0)
4077         retVal = strlen(sDestination) + 1;
4078     else
4079     {
4080         strncpy (lpNumberStr, sDestination, cchNumber-1);
4081         *(lpNumberStr+cchNumber-1) = '\0';   /* ensure we got a NULL at the end */
4082         retVal = strlen(lpNumberStr);
4083     }
4084
4085     return retVal;
4086 }
4087
4088 /**************************************************************************
4089  *              GetNumberFormatW        (KERNEL32.xxx)
4090  */
4091 INT WINAPI GetNumberFormatW(LCID locale, DWORD dwflags,
4092                                LPCWSTR lpvalue,  const NUMBERFMTW * lpFormat,
4093                                LPWSTR lpNumberStr, int cchNumber)
4094 {
4095  FIXME("%s: stub, no reformating done\n",debugstr_w(lpvalue));
4096
4097  lstrcpynW( lpNumberStr, lpvalue, cchNumber );
4098  return cchNumber? lstrlenW( lpNumberStr ) : 0;
4099 }
4100
4101 /**************************************************************************
4102  *              GetCurrencyFormatA      (KERNEL32.302)
4103  */
4104 INT WINAPI GetCurrencyFormatA(LCID locale, DWORD dwflags,
4105                                LPCSTR lpvalue,   const CURRENCYFMTA * lpFormat,
4106                                LPSTR lpCurrencyStr, int cchCurrency)
4107 {
4108     UINT   nPosOrder, nNegOrder;
4109     INT    retVal;
4110     char   sDestination[128], sNegOrder[8], sPosOrder[8], sCurrencySymbol[8];
4111     char   *pDestination = sDestination;
4112     char   sNumberFormated[128];
4113     char   *pNumberFormated = sNumberFormated;
4114     LCID   systemDefaultLCID;
4115     BOOL   bIsPositive = FALSE, bValidFormat = FALSE;
4116     enum   Operations
4117     {
4118         USE_PARAMETER,
4119         USE_LOCALEINFO,
4120         USE_SYSTEMDEFAULT,
4121         RETURN_ERROR
4122     } used_operation;
4123
4124     NUMBERFMTA  numberFmt;
4125
4126     /* Which source will we use to format the string */
4127     used_operation = RETURN_ERROR;
4128     if (lpFormat != NULL)
4129     {
4130         if (dwflags == 0)
4131             used_operation = USE_PARAMETER;
4132     }
4133     else
4134     {
4135         if (dwflags & LOCALE_NOUSEROVERRIDE)
4136             used_operation = USE_LOCALEINFO;
4137         else
4138             used_operation = USE_SYSTEMDEFAULT;
4139     }
4140
4141     /* Load the fields we need */
4142     switch(used_operation)
4143     {
4144     case USE_LOCALEINFO:
4145         /* Specific to CURRENCYFMTA*/
4146         GetLocaleInfoA(locale, LOCALE_INEGCURR, sNegOrder, sizeof(sNegOrder));
4147         GetLocaleInfoA(locale, LOCALE_ICURRENCY, sPosOrder, sizeof(sPosOrder));
4148         GetLocaleInfoA(locale, LOCALE_SCURRENCY, sCurrencySymbol, sizeof(sCurrencySymbol));
4149
4150         nPosOrder = atoi(sPosOrder);
4151         nNegOrder = atoi(sNegOrder);
4152         break;
4153     case USE_PARAMETER:
4154         /* Specific to CURRENCYFMTA*/
4155         nNegOrder = lpFormat->NegativeOrder;
4156         nPosOrder = lpFormat->PositiveOrder;
4157         strcpy(sCurrencySymbol, lpFormat->lpCurrencySymbol);
4158         break;
4159     case USE_SYSTEMDEFAULT:
4160         systemDefaultLCID = GetSystemDefaultLCID();
4161         /* Specific to CURRENCYFMTA*/
4162         GetLocaleInfoA(systemDefaultLCID, LOCALE_INEGCURR, sNegOrder, sizeof(sNegOrder));
4163         GetLocaleInfoA(systemDefaultLCID, LOCALE_ICURRENCY, sPosOrder, sizeof(sPosOrder));
4164         GetLocaleInfoA(systemDefaultLCID, LOCALE_SCURRENCY, sCurrencySymbol, sizeof(sCurrencySymbol));
4165
4166         nPosOrder = atoi(sPosOrder);
4167         nNegOrder = atoi(sNegOrder);
4168         break;
4169     default:
4170         SetLastError(ERROR_INVALID_PARAMETER);
4171         return 0;
4172     }
4173
4174     /* Construct a temporary number format structure */
4175     if (lpFormat != NULL)
4176     {
4177         numberFmt.NumDigits     = lpFormat->NumDigits;
4178         numberFmt.LeadingZero   = lpFormat->LeadingZero;
4179         numberFmt.Grouping      = lpFormat->Grouping;
4180         numberFmt.NegativeOrder = 0;
4181         numberFmt.lpDecimalSep = lpFormat->lpDecimalSep;
4182         numberFmt.lpThousandSep = lpFormat->lpThousandSep;
4183         bValidFormat = TRUE;
4184     }
4185
4186     /* Make a call to GetNumberFormatA() */
4187     if (*lpvalue == '-')
4188     {
4189         bIsPositive = FALSE;
4190         retVal = GetNumberFormatA(locale,0,lpvalue+1,(bValidFormat)?&numberFmt:NULL,pNumberFormated,128);
4191     }
4192     else
4193     {
4194         bIsPositive = TRUE;
4195         retVal = GetNumberFormatA(locale,0,lpvalue,(bValidFormat)?&numberFmt:NULL,pNumberFormated,128);
4196     }
4197
4198     if (retVal == 0)
4199         return 0;
4200
4201     /* construct the formatted string */
4202     if (bIsPositive)
4203     {
4204         switch (nPosOrder)
4205         {
4206         case 0:   /* Prefix, no separation */
4207             strcpy (pDestination, sCurrencySymbol);
4208             strcat (pDestination, pNumberFormated);
4209             break;
4210         case 1:   /* Suffix, no separation */
4211             strcpy (pDestination, pNumberFormated);
4212             strcat (pDestination, sCurrencySymbol);
4213             break;
4214         case 2:   /* Prefix, 1 char separation */
4215             strcpy (pDestination, sCurrencySymbol);
4216             strcat (pDestination, " ");
4217             strcat (pDestination, pNumberFormated);
4218             break;
4219         case 3:   /* Suffix, 1 char separation */
4220             strcpy (pDestination, pNumberFormated);
4221             strcat (pDestination, " ");
4222             strcat (pDestination, sCurrencySymbol);
4223             break;
4224         default:
4225             SetLastError(ERROR_INVALID_PARAMETER);
4226             return 0;
4227         }
4228     }
4229     else  /* negative number */
4230     {
4231         switch (nNegOrder)
4232         {
4233         case 0:   /* format: ($1.1) */
4234             strcpy (pDestination, "(");
4235             strcat (pDestination, sCurrencySymbol);
4236             strcat (pDestination, pNumberFormated);
4237             strcat (pDestination, ")");
4238             break;
4239         case 1:   /* format: -$1.1 */
4240             strcpy (pDestination, "-");
4241             strcat (pDestination, sCurrencySymbol);
4242             strcat (pDestination, pNumberFormated);
4243             break;
4244         case 2:   /* format: $-1.1 */
4245             strcpy (pDestination, sCurrencySymbol);
4246             strcat (pDestination, "-");
4247             strcat (pDestination, pNumberFormated);
4248             break;
4249         case 3:   /* format: $1.1- */
4250             strcpy (pDestination, sCurrencySymbol);
4251             strcat (pDestination, pNumberFormated);
4252             strcat (pDestination, "-");
4253             break;
4254         case 4:   /* format: (1.1$) */
4255             strcpy (pDestination, "(");
4256             strcat (pDestination, pNumberFormated);
4257             strcat (pDestination, sCurrencySymbol);
4258             strcat (pDestination, ")");
4259             break;
4260         case 5:   /* format: -1.1$ */
4261             strcpy (pDestination, "-");
4262             strcat (pDestination, pNumberFormated);
4263             strcat (pDestination, sCurrencySymbol);
4264             break;
4265         case 6:   /* format: 1.1-$ */
4266             strcpy (pDestination, pNumberFormated);
4267             strcat (pDestination, "-");
4268             strcat (pDestination, sCurrencySymbol);
4269             break;
4270         case 7:   /* format: 1.1$- */
4271             strcpy (pDestination, pNumberFormated);
4272             strcat (pDestination, sCurrencySymbol);
4273             strcat (pDestination, "-");
4274             break;
4275         case 8:   /* format: -1.1 $ */
4276             strcpy (pDestination, "-");
4277             strcat (pDestination, pNumberFormated);
4278             strcat (pDestination, " ");
4279             strcat (pDestination, sCurrencySymbol);
4280             break;
4281         case 9:   /* format: -$ 1.1 */
4282             strcpy (pDestination, "-");
4283             strcat (pDestination, sCurrencySymbol);
4284             strcat (pDestination, " ");
4285             strcat (pDestination, pNumberFormated);
4286             break;
4287         case 10:   /* format: 1.1 $- */
4288             strcpy (pDestination, pNumberFormated);
4289             strcat (pDestination, " ");
4290             strcat (pDestination, sCurrencySymbol);
4291             strcat (pDestination, "-");
4292             break;
4293         case 11:   /* format: $ 1.1- */
4294             strcpy (pDestination, sCurrencySymbol);
4295             strcat (pDestination, " ");
4296             strcat (pDestination, pNumberFormated);
4297             strcat (pDestination, "-");
4298             break;
4299         case 12:   /* format: $ -1.1 */
4300             strcpy (pDestination, sCurrencySymbol);
4301             strcat (pDestination, " ");
4302             strcat (pDestination, "-");
4303             strcat (pDestination, pNumberFormated);
4304             break;
4305         case 13:   /* format: 1.1- $ */
4306             strcpy (pDestination, pNumberFormated);
4307             strcat (pDestination, "-");
4308             strcat (pDestination, " ");
4309             strcat (pDestination, sCurrencySymbol);
4310             break;
4311         case 14:   /* format: ($ 1.1) */
4312             strcpy (pDestination, "(");
4313             strcat (pDestination, sCurrencySymbol);
4314             strcat (pDestination, " ");
4315             strcat (pDestination, pNumberFormated);
4316             strcat (pDestination, ")");
4317             break;
4318         case 15:   /* format: (1.1 $) */
4319             strcpy (pDestination, "(");
4320             strcat (pDestination, pNumberFormated);
4321             strcat (pDestination, " ");
4322             strcat (pDestination, sCurrencySymbol);
4323             strcat (pDestination, ")");
4324             break;
4325         default:
4326             SetLastError(ERROR_INVALID_PARAMETER);
4327             return 0;
4328         }
4329     }
4330
4331     if (cchCurrency == 0)
4332         return strlen(pDestination) + 1;
4333
4334     else
4335     {
4336         strncpy (lpCurrencyStr, pDestination, cchCurrency-1);
4337         *(lpCurrencyStr+cchCurrency-1) = '\0';   /* ensure we got a NULL at the end */
4338         return  strlen(lpCurrencyStr);
4339     }
4340 }
4341
4342 /**************************************************************************
4343  *              GetCurrencyFormatW      (KERNEL32.303)
4344  */
4345 INT WINAPI GetCurrencyFormatW(LCID locale, DWORD dwflags,
4346                                LPCWSTR lpvalue,   const CURRENCYFMTW * lpFormat,
4347                                LPWSTR lpCurrencyStr, int cchCurrency)
4348 {
4349     FIXME("This API function is NOT implemented !\n");
4350     return 0;
4351 }
4352
4353 /******************************************************************************
4354  *              OLE2NLS_CheckLocale     [intern]
4355  */
4356 static LCID OLE2NLS_CheckLocale (LCID locale)
4357 {
4358         if (!locale)
4359         { locale = LOCALE_SYSTEM_DEFAULT;
4360         }
4361
4362         if (locale == LOCALE_SYSTEM_DEFAULT)
4363         { return GetSystemDefaultLCID();
4364         }
4365         else if (locale == LOCALE_USER_DEFAULT)
4366         { return GetUserDefaultLCID();
4367         }
4368         else
4369         { return locale;
4370         }
4371 }
4372 /******************************************************************************
4373  *              GetTimeFormatA  [KERNEL32.422]
4374  * Makes an ASCII string of the time
4375  *
4376  * Formats date according to format,  or locale default if format is
4377  * NULL. The format consists of literal characters and fields as follows:
4378  *
4379  * h  hours with no leading zero (12-hour)
4380  * hh hours with full two digits
4381  * H  hours with no leading zero (24-hour)
4382  * HH hours with full two digits
4383  * m  minutes with no leading zero
4384  * mm minutes with full two digits
4385  * s  seconds with no leading zero
4386  * ss seconds with full two digits
4387  * t  time marker (A or P)
4388  * tt time marker (AM, PM)
4389  *
4390  */
4391 INT WINAPI
4392 GetTimeFormatA(LCID locale,        /* in  */
4393                  DWORD flags,        /* in  */
4394                  LPSYSTEMTIME xtime, /* in  */
4395                  LPCSTR format,      /* in  */
4396                  LPSTR timestr,      /* out */
4397                  INT timelen       /* in  */)
4398 { char format_buf[40];
4399   LPCSTR thisformat;
4400   SYSTEMTIME t;
4401   LPSYSTEMTIME thistime;
4402   LCID thislocale=0;
4403   DWORD thisflags=LOCALE_STIMEFORMAT; /* standart timeformat */
4404   INT ret;
4405
4406   TRACE("GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,xtime,format,timestr,timelen);
4407
4408   thislocale = OLE2NLS_CheckLocale ( locale );
4409
4410   if ( flags & (TIME_NOTIMEMARKER | TIME_FORCE24HOURFORMAT ))
4411   { FIXME("TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
4412   }
4413
4414   flags &= (TIME_NOSECONDS | TIME_NOMINUTESORSECONDS); /* mask for OLE_GetFormatA*/
4415
4416   if (format == NULL)
4417   { if (flags & LOCALE_NOUSEROVERRIDE)  /*use system default*/
4418     { thislocale = GetSystemDefaultLCID();
4419     }
4420     GetLocaleInfoA(thislocale, thisflags, format_buf, sizeof(format_buf));
4421     thisformat = format_buf;
4422   }
4423   else
4424   { thisformat = format;
4425   }
4426
4427   if (xtime == NULL) /* NULL means use the current local time*/
4428   { GetLocalTime(&t);
4429     thistime = &t;
4430   }
4431   else
4432   { thistime = xtime;
4433   }
4434   ret = OLE_GetFormatA(thislocale, thisflags, flags, thistime, thisformat,
4435                          timestr, timelen);
4436   return ret;
4437 }
4438
4439
4440 /******************************************************************************
4441  *              GetTimeFormatW  [KERNEL32.423]
4442  * Makes a Unicode string of the time
4443  */
4444 INT WINAPI
4445 GetTimeFormatW(LCID locale,        /* in  */
4446                  DWORD flags,        /* in  */
4447                  LPSYSTEMTIME xtime, /* in  */
4448                  LPCWSTR format,     /* in  */
4449                  LPWSTR timestr,     /* out */
4450                  INT timelen       /* in  */)
4451 {       WCHAR format_buf[40];
4452         LPCWSTR thisformat;
4453         SYSTEMTIME t;
4454         LPSYSTEMTIME thistime;
4455         LCID thislocale=0;
4456         DWORD thisflags=LOCALE_STIMEFORMAT; /* standart timeformat */
4457         INT ret;
4458
4459         TRACE("GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,
4460         xtime,debugstr_w(format),timestr,timelen);
4461
4462         thislocale = OLE2NLS_CheckLocale ( locale );
4463
4464         if ( flags & (TIME_NOTIMEMARKER | TIME_FORCE24HOURFORMAT ))
4465         { FIXME("TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
4466         }
4467
4468         flags &= (TIME_NOSECONDS | TIME_NOMINUTESORSECONDS); /* mask for OLE_GetFormatA*/
4469
4470         if (format == NULL)
4471         { if (flags & LOCALE_NOUSEROVERRIDE)  /*use system default*/
4472           { thislocale = GetSystemDefaultLCID();
4473           }
4474           GetLocaleInfoW(thislocale, thisflags, format_buf, 40);
4475           thisformat = format_buf;
4476         }
4477         else
4478         { thisformat = format;
4479         }
4480
4481         if (xtime == NULL) /* NULL means use the current local time*/
4482         { GetSystemTime(&t);
4483           thistime = &t;
4484         }
4485         else
4486         { thistime = xtime;
4487         }
4488
4489         ret = OLE_GetFormatW(thislocale, thisflags, flags, thistime, thisformat,
4490                          timestr, timelen);
4491         return ret;
4492 }
4493
4494 /******************************************************************************
4495  *              EnumCalendarInfoA       [KERNEL32.196]
4496  */
4497 BOOL WINAPI EnumCalendarInfoA(
4498         CALINFO_ENUMPROCA calinfoproc,LCID locale,CALID calendar,CALTYPE caltype
4499 ) {
4500         FIXME("(%p,0x%04lx,0x%08lx,0x%08lx),stub!\n",calinfoproc,locale,calendar,caltype);
4501         return FALSE;
4502 }