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  */
   7
   8 #include <string.h>
   9 #include <ctype.h>
  10 #include <stdlib.h>
  11 #include "windows.h"
  12 #include "heap.h"
  13 #include "ole.h"
  14 #include "options.h"
  15 #include "winnls.h"
  16 #include "winreg.h"
  17 #include "winerror.h"
  18 #include "debug.h"
  19 #include "main.h"
  20
  21 struct NLS_langlocale {
  22         const int lang;
  23         struct NLS_localevar {
  24                 const int       type;
  25                 const char      *val;
  26         } locvars[150];
  27 };
  28
  29 #define LANG_BEGIN(l,s) {       MAKELANGID(l,s), {
  30
  31 #define LOCVAL(type,value)                                      {type,value},
  32
  33 #define LANG_END                                         }},
  34
  35 static const struct NLS_langlocale langlocales[] = {
  36 /* add languages in numerical order of main language (last two digits)
  37  * it is much easier to find the missing holes that way */
  38
  39 LANG_BEGIN (LANG_CATALAN, SUBLANG_DEFAULT)      /*0x0403*/
  40 #include "nls/cat.nls"
  41 LANG_END
  42
  43 LANG_BEGIN (LANG_CZECH, SUBLANG_DEFAULT)        /*0x0405*/
  44 #include "nls/cze.nls"
  45 LANG_END
  46
  47 LANG_BEGIN (LANG_DANISH, SUBLANG_DEFAULT)       /*0x0406*/
  48 #include "nls/dan.nls"
  49 LANG_END
  50
  51 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN)                /*0x0407*/
  52 #include "nls/deu.nls"
  53 LANG_END
  54 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_SWISS)          /*0x0807*/
  55 #include "nls/des.nls"
  56 LANG_END
  57 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_AUSTRIAN)       /*0x0C07*/
  58 #include "nls/dea.nls"
  59 LANG_END
  60 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_LUXEMBOURG)     /*0x1007*/
  61 #include "nls/del.nls"
  62 LANG_END
  63 LANG_BEGIN (LANG_GERMAN, SUBLANG_GERMAN_LIECHTENSTEIN)  /*0x1407*/
  64 #include "nls/dec.nls"
  65 LANG_END
  66
  67 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_US)           /*0x0409*/
  68 #include "nls/enu.nls"
  69 LANG_END
  70 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_UK)           /*0x0809*/
  71 #include "nls/eng.nls"
  72 LANG_END
  73 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_AUS)          /*0x0C09*/
  74 #include "nls/ena.nls"
  75 LANG_END
  76 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_CAN)          /*0x1009*/
  77 #include "nls/enc.nls"
  78 LANG_END
  79 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_NZ)           /*0x1409*/
  80 #include "nls/enz.nls"
  81 LANG_END
  82 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_EIRE)         /*0x1809*/
  83 #include "nls/irl.nls"
  84 LANG_END
  85 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_SAFRICA)      /*0x1C09*/
  86 #include "nls/ens.nls"
  87 LANG_END
  88 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_JAMAICA)      /*0x2009*/
  89 #include "nls/enj.nls"
  90 LANG_END
  91 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_CARRIBEAN)    /*0x2409*/
  92 #include "nls/enb.nls"
  93 LANG_END
  94 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_BELIZE)       /*0x2809*/
  95 #include "nls/enl.nls"
  96 LANG_END
  97 LANG_BEGIN (LANG_ENGLISH, SUBLANG_ENGLISH_TRINIDAD)     /*0x2C09*/
  98 #include "nls/ent.nls"
  99 LANG_END
 100
 101 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH)              /*0x040a*/
 102 #include "nls/esp.nls"
 103 LANG_END
 104 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_MEXICAN)      /*0x080a*/
 105 #include "nls/esm.nls"
 106 LANG_END
 107 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_MODERN)       /*0x0C0a*/
 108 #include "nls/esn.nls"
 109 LANG_END
 110 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_GUATEMALA)    /*0x100a*/
 111 #include "nls/esg.nls"
 112 LANG_END
 113 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_COSTARICA)    /*0x140a*/
 114 #include "nls/esc.nls"
 115 LANG_END
 116 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PANAMA)       /*0x180a*/
 117 #include "nls/esa.nls"
 118 LANG_END
 119 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_DOMINICAN)    /*0x1C0A*/
 120 #include "nls/esd.nls"
 121 LANG_END
 122 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_VENEZUELA)    /*0x200a*/
 123 #include "nls/esv.nls"
 124 LANG_END
 125 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_COLOMBIA)     /*0x240a*/
 126 #include "nls/eso.nls"
 127 LANG_END
 128 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PERU)         /*0x280a*/
 129 #include "nls/esr.nls"
 130 LANG_END
 131 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_ARGENTINA)    /*0x2c0a*/
 132 #include "nls/ess.nls"
 133 LANG_END
 134 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_ECUADOR)      /*0x300a*/
 135 #include "nls/esf.nls"
 136 LANG_END
 137 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_CHILE)        /*0x340a*/
 138 #include "nls/esl.nls"
 139 LANG_END
 140 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_URUGUAY)      /*0x380a*/
 141 #include "nls/esy.nls"
 142 LANG_END
 143 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PARAGUAY)     /*0x3c0a*/
 144 #include "nls/esz.nls"
 145 LANG_END
 146 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_BOLIVIA)      /*0x400a*/
 147 #include "nls/esb.nls"
 148 LANG_END
 149 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_EL_SALVADOR)  /*0x440a*/
 150 #include "nls/ese.nls"
 151 LANG_END
 152 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_HONDURAS)     /*0x480a*/
 153 #include "nls/esh.nls"
 154 LANG_END
 155 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_NICARAGUA)    /*0x4c0a*/
 156 #include "nls/esi.nls"
 157 LANG_END
 158 LANG_BEGIN (LANG_SPANISH, SUBLANG_SPANISH_PUERTO_RICO)  /*0x500a*/
 159 #include "nls/esu.nls"
 160 LANG_END
 161
 162 LANG_BEGIN (LANG_FINNISH, SUBLANG_DEFAULT)      /*0x040B*/
 163 #include "nls/fin.nls"
 164 LANG_END
 165
 166 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH)                /*0x040C*/
 167 #include "nls/fra.nls"
 168 LANG_END
 169 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_BELGIAN)        /*0x080C*/
 170 #include "nls/frb.nls"
 171 LANG_END
 172 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_CANADIAN)       /*0x0C0C*/
 173 #include "nls/frc.nls"
 174 LANG_END
 175 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_SWISS)          /*0x100C*/
 176 #include "nls/frs.nls"
 177 LANG_END
 178 LANG_BEGIN (LANG_FRENCH, SUBLANG_FRENCH_LUXEMBOURG)     /*0x140C*/
 179 #include "nls/frl.nls"
 180 LANG_END
 181
 182 LANG_BEGIN (LANG_HUNGARIAN, SUBLANG_DEFAULT)    /*0x040e*/
 183 #include "nls/hun.nls"
 184 LANG_END
 185
 186 LANG_BEGIN (LANG_ITALIAN, SUBLANG_ITALIAN)              /*0x0410*/
 187 #include "nls/ita.nls"
 188 LANG_END
 189 LANG_BEGIN (LANG_ITALIAN, SUBLANG_ITALIAN_SWISS)        /*0x0810*/
 190 #include "nls/its.nls"
 191 LANG_END
 192
 193 LANG_BEGIN (LANG_KOREAN, SUBLANG_KOREAN)        /*0x0412*/
 194 #include "nls/kor.nls"
 195 LANG_END
 196
 197 LANG_BEGIN (LANG_NORWEGIAN, SUBLANG_NORWEGIAN_BOKMAL)   /*0x0414*/
 198 #include "nls/nor.nls"
 199 LANG_END
 200 LANG_BEGIN (LANG_NORWEGIAN, SUBLANG_NORWEGIAN_NYNORSK)  /*0x0814*/
 201 #include "nls/non.nls"
 202 LANG_END
 203
 204 LANG_BEGIN (LANG_POLISH, SUBLANG_DEFAULT)       /*0x0415*/
 205 #include "nls/plk.nls"
 206 LANG_END
 207
 208 LANG_BEGIN (LANG_PORTUGUESE ,SUBLANG_PORTUGUESE_BRAZILIAN)      /*0x0416*/
 209 #include "nls/ptb.nls"
 210 LANG_END
 211 LANG_BEGIN (LANG_PORTUGUESE ,SUBLANG_PORTUGUESE)                /*0x0816*/
 212 #include "nls/ptg.nls"
 213 LANG_END
 214
 215 LANG_BEGIN (LANG_SLOVAK, SUBLANG_DEFAULT)       /*0x041b*/
 216 #include "nls/sky.nls"
 217 LANG_END
 218
 219 LANG_BEGIN (LANG_SWEDISH, SUBLANG_SWEDISH)              /*0x041d*/
 220 #include "nls/sve.nls"
 221 LANG_END
 222 LANG_BEGIN (LANG_SWEDISH, SUBLANG_SWEDISH_FINLAND)      /*0x081d*/
 223 #include "nls/svf.nls"
 224 LANG_END
 225
 226 LANG_BEGIN (LANG_THAI, SUBLANG_DEFAULT) /*0x41e*/
 227 #include "nls/tha.nls"
 228 LANG_END
 229
 230 LANG_BEGIN (LANG_ESPERANTO, SUBLANG_DEFAULT)    /*0x048f*/
 231 #include "nls/esperanto.nls"
 232 LANG_END
 233             };
 234
 235
 236 /* Locale name to id map. used by EnumSystemLocales, GetLocalInfoA
 237  * MUST contain all #defines from winnls.h
 238  * last entry has NULL name, 0 id.
 239  */
 240 #define LOCALE_ENTRY(x) {#x,LOCALE_##x}
 241 static struct tagLOCALE_NAME2ID {
 242         char    *name;
 243         DWORD   id;
 244 } locale_name2id[]= {
 245         LOCALE_ENTRY(ILANGUAGE),
 246         LOCALE_ENTRY(SLANGUAGE),
 247         LOCALE_ENTRY(SENGLANGUAGE),
 248         LOCALE_ENTRY(SABBREVLANGNAME),
 249         LOCALE_ENTRY(SNATIVELANGNAME),
 250         LOCALE_ENTRY(ICOUNTRY),
 251         LOCALE_ENTRY(SCOUNTRY),
 252         LOCALE_ENTRY(SENGCOUNTRY),
 253         LOCALE_ENTRY(SABBREVCTRYNAME),
 254         LOCALE_ENTRY(SNATIVECTRYNAME),
 255         LOCALE_ENTRY(IDEFAULTLANGUAGE),
 256         LOCALE_ENTRY(IDEFAULTCOUNTRY),
 257         LOCALE_ENTRY(IDEFAULTCODEPAGE),
 258         LOCALE_ENTRY(IDEFAULTANSICODEPAGE),
 259         LOCALE_ENTRY(IDEFAULTMACCODEPAGE),
 260         LOCALE_ENTRY(SLIST),
 261         LOCALE_ENTRY(IMEASURE),
 262         LOCALE_ENTRY(SDECIMAL),
 263         LOCALE_ENTRY(STHOUSAND),
 264         LOCALE_ENTRY(SGROUPING),
 265         LOCALE_ENTRY(IDIGITS),
 266         LOCALE_ENTRY(ILZERO),
 267         LOCALE_ENTRY(INEGNUMBER),
 268         LOCALE_ENTRY(SNATIVEDIGITS),
 269         LOCALE_ENTRY(SCURRENCY),
 270         LOCALE_ENTRY(SINTLSYMBOL),
 271         LOCALE_ENTRY(SMONDECIMALSEP),
 272         LOCALE_ENTRY(SMONTHOUSANDSEP),
 273         LOCALE_ENTRY(SMONGROUPING),
 274         LOCALE_ENTRY(ICURRDIGITS),
 275         LOCALE_ENTRY(IINTLCURRDIGITS),
 276         LOCALE_ENTRY(ICURRENCY),
 277         LOCALE_ENTRY(INEGCURR),
 278         LOCALE_ENTRY(SDATE),
 279         LOCALE_ENTRY(STIME),
 280         LOCALE_ENTRY(SSHORTDATE),
 281         LOCALE_ENTRY(SLONGDATE),
 282         LOCALE_ENTRY(STIMEFORMAT),
 283         LOCALE_ENTRY(IDATE),
 284         LOCALE_ENTRY(ILDATE),
 285         LOCALE_ENTRY(ITIME),
 286         LOCALE_ENTRY(ITIMEMARKPOSN),
 287         LOCALE_ENTRY(ICENTURY),
 288         LOCALE_ENTRY(ITLZERO),
 289         LOCALE_ENTRY(IDAYLZERO),
 290         LOCALE_ENTRY(IMONLZERO),
 291         LOCALE_ENTRY(S1159),
 292         LOCALE_ENTRY(S2359),
 293         LOCALE_ENTRY(ICALENDARTYPE),
 294         LOCALE_ENTRY(IOPTIONALCALENDAR),
 295         LOCALE_ENTRY(IFIRSTDAYOFWEEK),
 296         LOCALE_ENTRY(IFIRSTWEEKOFYEAR),
 297         LOCALE_ENTRY(SDAYNAME1),
 298         LOCALE_ENTRY(SDAYNAME2),
 299         LOCALE_ENTRY(SDAYNAME3),
 300         LOCALE_ENTRY(SDAYNAME4),
 301         LOCALE_ENTRY(SDAYNAME5),
 302         LOCALE_ENTRY(SDAYNAME6),
 303         LOCALE_ENTRY(SDAYNAME7),
 304         LOCALE_ENTRY(SABBREVDAYNAME1),
 305         LOCALE_ENTRY(SABBREVDAYNAME2),
 306         LOCALE_ENTRY(SABBREVDAYNAME3),
 307         LOCALE_ENTRY(SABBREVDAYNAME4),
 308         LOCALE_ENTRY(SABBREVDAYNAME5),
 309         LOCALE_ENTRY(SABBREVDAYNAME6),
 310         LOCALE_ENTRY(SABBREVDAYNAME7),
 311         LOCALE_ENTRY(SMONTHNAME1),
 312         LOCALE_ENTRY(SMONTHNAME2),
 313         LOCALE_ENTRY(SMONTHNAME3),
 314         LOCALE_ENTRY(SMONTHNAME4),
 315         LOCALE_ENTRY(SMONTHNAME5),
 316         LOCALE_ENTRY(SMONTHNAME6),
 317         LOCALE_ENTRY(SMONTHNAME7),
 318         LOCALE_ENTRY(SMONTHNAME8),
 319         LOCALE_ENTRY(SMONTHNAME9),
 320         LOCALE_ENTRY(SMONTHNAME10),
 321         LOCALE_ENTRY(SMONTHNAME11),
 322         LOCALE_ENTRY(SMONTHNAME12),
 323         LOCALE_ENTRY(SMONTHNAME13),
 324         LOCALE_ENTRY(SABBREVMONTHNAME1),
 325         LOCALE_ENTRY(SABBREVMONTHNAME2),
 326         LOCALE_ENTRY(SABBREVMONTHNAME3),
 327         LOCALE_ENTRY(SABBREVMONTHNAME4),
 328         LOCALE_ENTRY(SABBREVMONTHNAME5),
 329         LOCALE_ENTRY(SABBREVMONTHNAME6),
 330         LOCALE_ENTRY(SABBREVMONTHNAME7),
 331         LOCALE_ENTRY(SABBREVMONTHNAME8),
 332         LOCALE_ENTRY(SABBREVMONTHNAME9),
 333         LOCALE_ENTRY(SABBREVMONTHNAME10),
 334         LOCALE_ENTRY(SABBREVMONTHNAME11),
 335         LOCALE_ENTRY(SABBREVMONTHNAME12),
 336         LOCALE_ENTRY(SABBREVMONTHNAME13),
 337         LOCALE_ENTRY(SPOSITIVESIGN),
 338         LOCALE_ENTRY(SNEGATIVESIGN),
 339         LOCALE_ENTRY(IPOSSIGNPOSN),
 340         LOCALE_ENTRY(INEGSIGNPOSN),
 341         LOCALE_ENTRY(IPOSSYMPRECEDES),
 342         LOCALE_ENTRY(IPOSSEPBYSPACE),
 343         LOCALE_ENTRY(INEGSYMPRECEDES),
 344         LOCALE_ENTRY(INEGSEPBYSPACE),
 345         LOCALE_ENTRY(FONTSIGNATURE),
 346         LOCALE_ENTRY(SISO639LANGNAME),
 347         LOCALE_ENTRY(SISO3166CTRYNAME),
 348         {NULL,0},
 349 };
 350
 351 const struct map_lcid2str {
 352         LCID            langid;
 353         const char      *langname;
 354 } languages[]={
 355         {0x0401,"Arabic (Saudi Arabia)"},
 356         {0x0801,"Arabic (Iraq)"},
 357         {0x0c01,"Arabic (Egypt)"},
 358         {0x1001,"Arabic (Libya)"},
 359         {0x1401,"Arabic (Algeria)"},
 360         {0x1801,"Arabic (Morocco)"},
 361         {0x1c01,"Arabic (Tunisia)"},
 362         {0x2001,"Arabic (Oman)"},
 363         {0x2401,"Arabic (Yemen)"},
 364         {0x2801,"Arabic (Syria)"},
 365         {0x2c01,"Arabic (Jordan)"},
 366         {0x3001,"Arabic (Lebanon)"},
 367         {0x3401,"Arabic (Kuwait)"},
 368         {0x3801,"Arabic (United Arab Emirates)"},
 369         {0x3c01,"Arabic (Bahrain)"},
 370         {0x4001,"Arabic (Qatar)"},
 371         {0x0402,"Bulgarian"},
 372         {0x0403,"Catalan"},
 373         {0x0404,"Chinese (Taiwan)"},
 374         {0x0804,"Chinese (People's Republic of China)"},
 375         {0x0c04,"Chinese (Hong Kong)"},
 376         {0x1004,"Chinese (Singapore)"},
 377         {0x1404,"Chinese (Macau)"},
 378         {0x0405,"Czech"},
 379         {0x0406,"Danish"},
 380         {0x0407,"German (Germany)"},
 381         {0x0807,"German (Switzerland)"},
 382         {0x0c07,"German (Austria)"},
 383         {0x1007,"German (Luxembourg)"},
 384         {0x1407,"German (Liechtenstein)"},
 385         {0x0408,"Greek"},
 386         {0x0409,"English (United States)"},
 387         {0x0809,"English (United Kingdom)"},
 388         {0x0c09,"English (Australia)"},
 389         {0x1009,"English (Canada)"},
 390         {0x1409,"English (New Zealand)"},
 391         {0x1809,"English (Ireland)"},
 392         {0x1c09,"English (South Africa)"},
 393         {0x2009,"English (Jamaica)"},
 394         {0x2409,"English (Caribbean)"},
 395         {0x2809,"English (Belize)"},
 396         {0x2c09,"English (Trinidad)"},
 397         {0x3009,"English (Zimbabwe)"},
 398         {0x3409,"English (Philippines)"},
 399         {0x040a,"Spanish (Spain, traditional sorting)"},
 400         {0x080a,"Spanish (Mexico)"},
 401         {0x0c0a,"Spanish (Spain, international sorting)"},
 402         {0x100a,"Spanish (Guatemala)"},
 403         {0x140a,"Spanish (Costa Rica)"},
 404         {0x180a,"Spanish (Panama)"},
 405         {0x1c0a,"Spanish (Dominican Republic)"},
 406         {0x200a,"Spanish (Venezuela)"},
 407         {0x240a,"Spanish (Colombia)"},
 408         {0x280a,"Spanish (Peru)"},
 409         {0x2c0a,"Spanish (Argentina)"},
 410         {0x300a,"Spanish (Ecuador)"},
 411         {0x340a,"Spanish (Chile)"},
 412         {0x380a,"Spanish (Uruguay)"},
 413         {0x3c0a,"Spanish (Paraguay)"},
 414         {0x400a,"Spanish (Bolivia)"},
 415         {0x440a,"Spanish (El Salvador)"},
 416         {0x480a,"Spanish (Honduras)"},
 417         {0x4c0a,"Spanish (Nicaragua)"},
 418         {0x500a,"Spanish (Puerto Rico)"},
 419         {0x040b,"Finnish"},
 420         {0x040c,"French (France)"},
 421         {0x080c,"French (Belgium)"},
 422         {0x0c0c,"French (Canada)"},
 423         {0x100c,"French (Switzerland)"},
 424         {0x140c,"French (Luxembourg)"},
 425         {0x180c,"French (Monaco)"},
 426         {0x040d,"Hebrew"},
 427         {0x040e,"Hungarian"},
 428         {0x040f,"Icelandic"},
 429         {0x0410,"Italian (Italy)"},
 430         {0x0810,"Italian (Switzerland)"},
 431         {0x0411,"Japanese"},
 432         {0x0412,"Korean (Wansung)"},
 433         {0x0812,"Korean (Johab)"},
 434         {0x0413,"Dutch (Netherlands)"},
 435         {0x0813,"Dutch (Belgium)"},
 436         {0x0414,"Norwegian (Bokmal)"},
 437         {0x0814,"Norwegian (Nynorsk)"},
 438         {0x0415,"Polish"},
 439         {0x0416,"Portuguese (Brazil)"},
 440         {0x0816,"Portuguese (Portugal)"},
 441         {0x0417,"Rhaeto Romanic"},
 442         {0x0418,"Romanian"},
 443         {0x0818,"Moldavian"},
 444         {0x0419,"Russian (Russia)"},
 445         {0x0819,"Russian (Moldavia)"},
 446         {0x041a,"Croatian"},
 447         {0x081a,"Serbian (latin)"},
 448         {0x0c1a,"Serbian (cyrillic)"},
 449         {0x041b,"Slovak"},
 450         {0x041c,"Albanian"},
 451         {0x041d,"Swedish (Sweden)"},
 452         {0x081d,"Swedish (Finland)"},
 453         {0x041e,"Thai"},
 454         {0x041f,"Turkish"},
 455         {0x0420,"Urdu"},
 456         {0x0421,"Indonesian"},
 457         {0x0422,"Ukrainian"},
 458         {0x0423,"Belarusian"},
 459         {0x0424,"Slovene"},
 460         {0x0425,"Estonian"},
 461         {0x0426,"Latvian"},
 462         {0x0427,"Lithuanian (modern)"},
 463         {0x0827,"Lithuanian (classic)"},
 464         {0x0428,"Maori"},
 465         {0x0429,"Farsi"},
 466         {0x042a,"Vietnamese"},
 467         {0x042b,"Armenian"},
 468         {0x042c,"Azeri (latin)"},
 469         {0x082c,"Azeri (cyrillic)"},
 470         {0x042d,"Basque"},
 471         {0x042e,"Sorbian"},
 472         {0x042f,"Macedonian"},
 473         {0x0430,"Sutu"},
 474         {0x0431,"Tsonga"},
 475         {0x0432,"Tswana"},
 476         {0x0433,"Venda"},
 477         {0x0434,"Xhosa"},
 478         {0x0435,"Zulu"},
 479         {0x0436,"Afrikaans"},
 480         {0x0437,"Georgian"},
 481         {0x0438,"Faeroese"},
 482         {0x0439,"Hindi"},
 483         {0x043a,"Maltese"},
 484         {0x043b,"Saami"},
 485         {0x043c,"Irish gaelic"},
 486         {0x083c,"Scottish gaelic"},
 487         {0x043e,"Malay (Malaysia)"},
 488         {0x083e,"Malay (Brunei Darussalam)"},
 489         {0x043f,"Kazak"},
 490         {0x0441,"Swahili"},
 491         {0x0443,"Uzbek (latin)"},
 492         {0x0843,"Uzbek (cyrillic)"},
 493         {0x0444,"Tatar"},
 494         {0x0445,"Bengali"},
 495         {0x0446,"Punjabi"},
 496         {0x0447,"Gujarati"},
 497         {0x0448,"Oriya"},
 498         {0x0449,"Tamil"},
 499         {0x044a,"Telugu"},
 500         {0x044b,"Kannada"},
 501         {0x044c,"Malayalam"},
 502         {0x044d,"Assamese"},
 503         {0x044e,"Marathi"},
 504         {0x044f,"Sanskrit"},
 505         {0x0457,"Konkani"},
 506         {0x048f,"Esperanto"}, /* Non official */
 507         {0x0000,"Unknown"}
 508     }, languages_de[]={
 509         {0x0401,"Arabic"},
 510         {0x0402,"Bulgarisch"},
 511         {0x0403,"Katalanisch"},
 512         {0x0404,"Traditionales Chinesisch"},
 513         {0x0405,"Tschecisch"},
 514         {0x0406,"Dänisch"},
 515         {0x0407,"Deutsch"},
 516         {0x0408,"Griechisch"},
 517         {0x0409,"Amerikanisches Englisch"},
 518         {0x040A,"Kastilisches Spanisch"},
 519         {0x040B,"Finnisch"},
 520         {0x040C,"Franzvsisch"},
 521         {0x040D,"Hebrdisch"},
 522         {0x040E,"Ungarisch"},
 523         {0x040F,"Isldndisch"},
 524         {0x0410,"Italienisch"},
 525         {0x0411,"Japanisch"},
 526         {0x0412,"Koreanisch"},
 527         {0x0413,"Niederldndisch"},
 528         {0x0414,"Norwegisch-Bokmal"},
 529         {0x0415,"Polnisch"},
 530         {0x0416,"Brasilianisches Portugiesisch"},
 531         {0x0417,"Rdtoromanisch"},
 532         {0x0418,"Rumdnisch"},
 533         {0x0419,"Russisch"},
 534         {0x041A,"Kroatoserbisch (lateinisch)"},
 535         {0x041B,"Slowenisch"},
 536         {0x041C,"Albanisch"},
 537         {0x041D,"Schwedisch"},
 538         {0x041E,"Thai"},
 539         {0x041F,"Türkisch"},
 540         {0x0420,"Urdu"},
 541         {0x0421,"Bahasa"},
 542         {0x0804,"Vereinfachtes Chinesisch"},
 543         {0x0807,"Schweizerdeutsch"},
 544         {0x0809,"Britisches Englisch"},
 545         {0x080A,"Mexikanisches Spanisch"},
 546         {0x080C,"Belgisches Franzvsisch"},
 547         {0x0810,"Schweizerisches Italienisch"},
 548         {0x0813,"Belgisches Niederldndisch"},
 549         {0x0814,"Norgwegisch-Nynorsk"},
 550         {0x0816,"Portugiesisch"},
 551         {0x081A,"Serbokratisch (kyrillisch)"},
 552         {0x0C1C,"Kanadisches Franzvsisch"},
 553         {0x100C,"Schweizerisches Franzvsisch"},
 554         {0x0000,"Unbekannt"},
 555 };
 556
 557 /***********************************************************************
 558  *           GetUserDefaultLCID       (OLE2NLS.1)
 559  */
 560 LCID WINAPI GetUserDefaultLCID()
 561 {
 562         return MAKELCID( GetUserDefaultLangID() , SORT_DEFAULT );
 563 }
 564
 565 /***********************************************************************
 566  *         GetSystemDefaultLCID       (OLE2NLS.2)
 567  */
 568 LCID WINAPI GetSystemDefaultLCID()
 569 {
 570         return GetUserDefaultLCID();
 571 }
 572
 573 /***********************************************************************
 574  *         GetUserDefaultLangID       (OLE2NLS.3)
 575  */
 576 LANGID WINAPI GetUserDefaultLangID()
 577 {
 578         /* caching result, if defined from environment, which should (?) not change during a WINE session */
 579         static  LANGID  userLCID = 0;
 580         if (Options.language) {
 581                 return Languages[Options.language].langid;
 582         }
 583
 584         if (userLCID == 0) {
 585                 char *buf=NULL;
 586                 char *lang,*country,*charset,*dialect,*next;
 587                 int     ret=0;
 588
 589                 buf=getenv("LANGUAGE");
 590                 if (!buf) buf=getenv("LANG");
 591                 if (!buf) buf=getenv("LC_ALL");
 592                 if (!buf) buf=getenv("LC_MESSAGES");
 593                 if (!buf) return userLCID = MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT );
 594
 595                 if (!strcmp(buf,"POSIX") || !strcmp(buf,"C")) {
 596                         return MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT );
 597                 }
 598
 599                 lang=buf;
 600
 601                 do {
 602                         next=strchr(lang,':'); if (next) *next++='\0';
 603                         dialect=strchr(lang,'@'); if (dialect) *dialect++='\0';
 604                         charset=strchr(lang,'.'); if (charset) *charset++='\0';
 605                         country=strchr(lang,'_'); if (country) *country++='\0';
 606
 607                         ret=MAIN_GetLanguageID(lang, country, charset, dialect);
 608
 609                         lang=next;
 610
 611                 } while (lang && !ret);
 612
 613                 /* FIXME : are strings returned by getenv() to be free()'ed ? */
 614                 userLCID = (LANGID)ret;
 615         }
 616         return userLCID;
 617 }
 618
 619 /***********************************************************************
 620  *         GetSystemDefaultLangID     (OLE2NLS.4)
 621  */
 622 LANGID WINAPI GetSystemDefaultLangID()
 623 {
 624         return GetUserDefaultLangID();
 625 }
 626
 627 /******************************************************************************
 628  *              GetLocaleInfo16 [OLE2NLS.5]
 629  * Is the last parameter really WORD for Win16?
 630  */
 631 INT16 WINAPI GetLocaleInfo16(LCID lcid,LCTYPE LCType,LPSTR buf,INT16 len)
 632 {
 633         return GetLocaleInfo32A(lcid,LCType,buf,len);
 634 }
 635
 636 /******************************************************************************
 637  * GetLocaleInfo32A [KERNEL32.342]
 638  */
 639 INT32 WINAPI GetLocaleInfo32A(LCID lcid,LCTYPE LCType,LPSTR buf,INT32 len)
 640 {
 641   LPCSTR  retString;
 642         int     found,i;
 643         int     lang=0;
 644
 645   TRACE(ole,"(lcid=0x%lx,lctype=0x%lx,%p,%x)\n",lcid,LCType,buf,len);
 646
 647   if (len && (! buf) ) {
 648     SetLastError(ERROR_INSUFFICIENT_BUFFER);
 649                 return 0;
 650         }
 651
 652   if (lcid == LOCALE_SYSTEM_DEFAULT || (LCType & LOCALE_NOUSEROVERRIDE) ) {
 653     lcid = GetSystemDefaultLCID();
 654   } else
 655     if (lcid == LOCALE_USER_DEFAULT) {
 656       lcid = GetUserDefaultLCID();
 657         }
 658         LCType &= ~(LOCALE_NOUSEROVERRIDE|LOCALE_USE_CP_ACP);
 659
 660         /* As an option, we could obtain the value from win.ini.
 661            This would not match the Wine compile-time option.
 662            Also, not all identifiers are available from win.ini */
 663         retString=0;
 664         /* If we are through all of this, retLen should not be zero anymore.
 665            If it is, the value is not supported */
 666         i=0;
 667         while (locale_name2id[i].name!=NULL) {
 668                 if (LCType == locale_name2id[i].id) {
 669                         retString = locale_name2id[i].name;
 670                         break;
 671                 }
 672                 i++;
 673         }
 674         if (!retString) {
 675       FIXME(ole,"Unkown LC type %lX\n",LCType);
 676                 return 0;
 677         }
 678
 679
 680     if ((lang & 0x3ff) == 0x000) /*LANG_NEUTRAL ==> US English*/ {
 681         lang = 0x0409;
 682         WARN(ole,"no language set, assume LANG_ENGLISH_US \n");
 683     }
 684
 685
 686     found=0;lang=lcid;
 687     for (i=0;i<3;i++) {
 688       int j;
 689
 690       for (j=0;j<sizeof(langlocales)/sizeof(langlocales[0]);j++) {
 691         if (langlocales[j].lang == lang) {
 692           int k;
 693
 694           for (k=0;k<sizeof(langlocales[j].locvars)/sizeof(langlocales[j].locvars[0]) && (langlocales[j].locvars[k].type);k++) {
 695             if (langlocales[j].locvars[k].type == LCType) {
 696               found = 1;
 697               retString = langlocales[j].locvars[k].val;
 698           break;
 699             }
 700           }
 701           if (found)
 702             break;
 703         }
 704       }
 705           /* language not found, try without a sublanguage*/
 706           if (i==1) lang=MAKELANGID( PRIMARYLANGID(lang), SUBLANG_DEFAULT);
 707           /* mask the LC Value */
 708           if (i==2) LCType &= 0xfff;
 709     }
 710
 711     if(!found) {
 712       ERR(ole,"'%s' not supported for your language (%4X).\n",
 713                         retString,lang);
 714                 SetLastError(ERROR_INVALID_PARAMETER);
 715                 return 0;
 716         }
 717         /* if len=0 return only the length, don't touch the buffer*/
 718         if (len)
 719                 lstrcpyn32A(buf,retString,len);
 720
 721         return strlen(retString)+1;
 722 }
 723
 724 /******************************************************************************
 725  *              GetLocaleInfo32W        [KERNEL32.343]
 726  *
 727  */
 728 INT32 WINAPI GetLocaleInfo32W(LCID lcid,LCTYPE LCType,LPWSTR wbuf,INT32 len)
 729 {       WORD wlen;
 730         LPSTR abuf;
 731
 732         if (len && (! wbuf) )
 733         { SetLastError(ERROR_INSUFFICIENT_BUFFER);
 734           return 0;
 735         }
 736
 737         abuf = (LPSTR)HeapAlloc(GetProcessHeap(),0,len);
 738         wlen = 2 * GetLocaleInfo32A(lcid, LCType, abuf, len);
 739
 740         if (wlen && len)        /* if len=0 return only the length*/
 741           lstrcpynAtoW(wbuf,abuf,len/2);
 742
 743         HeapFree(GetProcessHeap(),0,abuf);
 744         return wlen;
 745 }
 746
 747 /******************************************************************************
 748  *              SetLocaleInfoA  [KERNEL32.656]
 749  */
 750 BOOL16 WINAPI SetLocaleInfoA(DWORD lcid, DWORD lctype, LPCSTR data)
 751 {
 752     FIXME(ole,"(%ld,%ld,%s): stub\n",lcid,lctype,data);
 753     return TRUE;
 754 }
 755
 756 /******************************************************************************
 757  *              IsValidLocale   [KERNEL32.489]
 758  */
 759 BOOL32 WINAPI IsValidLocale(LCID lcid,DWORD flags)
 760 {
 761         /* we support ANY language. Well, at least say that...*/
 762         return TRUE;
 763 }
 764
 765 /******************************************************************************
 766  *              EnumSystemLocales32W    [KERNEL32.209]
 767  */
 768 BOOL32 WINAPI EnumSystemLocales32W( LOCALE_ENUMPROC32W lpfnLocaleEnum,
 769                                     DWORD flags )
 770 {
 771         int     i;
 772         BOOL32  ret;
 773         WCHAR   buffer[200];
 774         HKEY    xhkey;
 775
 776         TRACE(win32,"(%p,%08lx)\n",lpfnLocaleEnum,flags );
 777         /* see if we can reuse the Win95 registry entries.... */
 778         if (ERROR_SUCCESS==RegOpenKey32A(HKEY_LOCAL_MACHINE,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\",&xhkey)) {
 779                 i=0;
 780                 while (1) {
 781                         if (ERROR_SUCCESS!=RegEnumKey32W(xhkey,i,buffer,sizeof(buffer)))
 782                                 break;
 783                         if (!lpfnLocaleEnum(buffer))
 784                                 break;
 785                         i++;
 786                 }
 787                 RegCloseKey(xhkey);
 788                 return TRUE;
 789         }
 790
 791         i=0;
 792         while (languages[i].langname!=NULL)
 793         {
 794             LPWSTR cp;
 795             char   xbuffer[10];
 796
 797             sprintf(xbuffer,"%08lx",(DWORD)languages[i].langid);
 798
 799             cp = HEAP_strdupAtoW( GetProcessHeap(), 0, xbuffer );
 800             ret = lpfnLocaleEnum(cp);
 801             HeapFree( GetProcessHeap(), 0, cp );
 802             if (!ret) break;
 803             i++;
 804         }
 805         return TRUE;
 806 }
 807
 808 /******************************************************************************
 809  *              EnumSystemLocales32A    [KERNEL32.208]
 810  */
 811 BOOL32 WINAPI EnumSystemLocales32A(LOCALE_ENUMPROC32A lpfnLocaleEnum,
 812                                    DWORD flags)
 813 {
 814         int     i;
 815         CHAR    buffer[200];
 816         HKEY    xhkey;
 817
 818         TRACE(win32,"(%p,%08lx)\n",
 819                 lpfnLocaleEnum,flags
 820         );
 821         if (ERROR_SUCCESS==RegOpenKey32A(HKEY_LOCAL_MACHINE,"\\System\\CurrentControlSet\\control\\Nls\\Locale\\",&xhkey)) {
 822                 i=0;
 823                 while (1) {
 824                         if (ERROR_SUCCESS!=RegEnumKey32A(xhkey,i,buffer,sizeof(buffer)))
 825                                 break;
 826                         if (!lpfnLocaleEnum(buffer))
 827                                 break;
 828                         i++;
 829                 }
 830                 RegCloseKey(xhkey);
 831                 return TRUE;
 832         }
 833         i=0;
 834         while (languages[i].langname!=NULL) {
 835                 sprintf(buffer,"%08lx",(DWORD)languages[i].langid);
 836                 if (!lpfnLocaleEnum(buffer))
 837                         break;
 838                 i++;
 839         }
 840         return TRUE;
 841 }
 842
 843 static const unsigned char CT_CType2_LUT[] = {
 844   C2_NOTAPPLICABLE, /*   -   0 */
 845   C2_NOTAPPLICABLE, /*   -   1 */
 846   C2_NOTAPPLICABLE, /*   -   2 */
 847   C2_NOTAPPLICABLE, /*   -   3 */
 848   C2_NOTAPPLICABLE, /*   -   4 */
 849   C2_NOTAPPLICABLE, /*   -   5 */
 850   C2_NOTAPPLICABLE, /*   -   6 */
 851   C2_NOTAPPLICABLE, /*   -   7 */
 852   C2_NOTAPPLICABLE, /*   -   8 */
 853   C2_SEGMENTSEPARATOR, /*   -   9 */
 854   C2_NOTAPPLICABLE, /*   -  10 */
 855   C2_NOTAPPLICABLE, /*   -  11 */
 856   C2_NOTAPPLICABLE, /*   -  12 */
 857   C2_NOTAPPLICABLE, /*   -  13 */
 858   C2_NOTAPPLICABLE, /*   -  14 */
 859   C2_NOTAPPLICABLE, /*   -  15 */
 860   C2_NOTAPPLICABLE, /*   -  16 */
 861   C2_NOTAPPLICABLE, /*   -  17 */
 862   C2_NOTAPPLICABLE, /*   -  18 */
 863   C2_NOTAPPLICABLE, /*   -  19 */
 864   C2_NOTAPPLICABLE, /*   -  20 */
 865   C2_NOTAPPLICABLE, /*   -  21 */
 866   C2_NOTAPPLICABLE, /*   -  22 */
 867   C2_NOTAPPLICABLE, /*   -  23 */
 868   C2_NOTAPPLICABLE, /*   -  24 */
 869   C2_NOTAPPLICABLE, /*   -  25 */
 870   C2_NOTAPPLICABLE, /*   -  26 */
 871   C2_NOTAPPLICABLE, /*   -  27 */
 872   C2_NOTAPPLICABLE, /*   -  28 */
 873   C2_NOTAPPLICABLE, /*   -  29 */
 874   C2_NOTAPPLICABLE, /*   -  30 */
 875   C2_NOTAPPLICABLE, /*   -  31 */
 876   C2_WHITESPACE, /*   -  32 */
 877   C2_OTHERNEUTRAL, /* ! -  33 */
 878   C2_OTHERNEUTRAL, /* " -  34 */ /* " */
 879   C2_EUROPETERMINATOR, /* # -  35 */
 880   C2_EUROPETERMINATOR, /* $ -  36 */
 881   C2_EUROPETERMINATOR, /* % -  37 */
 882   C2_LEFTTORIGHT, /* & -  38 */
 883   C2_OTHERNEUTRAL, /* ' -  39 */
 884   C2_OTHERNEUTRAL, /* ( -  40 */
 885   C2_OTHERNEUTRAL, /* ) -  41 */
 886   C2_OTHERNEUTRAL, /* * -  42 */
 887   C2_EUROPETERMINATOR, /* + -  43 */
 888   C2_COMMONSEPARATOR, /* , -  44 */
 889   C2_EUROPETERMINATOR, /* - -  45 */
 890   C2_EUROPESEPARATOR, /* . -  46 */
 891   C2_EUROPESEPARATOR, /* / -  47 */
 892   C2_EUROPENUMBER, /* 0 -  48 */
 893   C2_EUROPENUMBER, /* 1 -  49 */
 894   C2_EUROPENUMBER, /* 2 -  50 */
 895   C2_EUROPENUMBER, /* 3 -  51 */
 896   C2_EUROPENUMBER, /* 4 -  52 */
 897   C2_EUROPENUMBER, /* 5 -  53 */
 898   C2_EUROPENUMBER, /* 6 -  54 */
 899   C2_EUROPENUMBER, /* 7 -  55 */
 900   C2_EUROPENUMBER, /* 8 -  56 */
 901   C2_EUROPENUMBER, /* 9 -  57 */
 902   C2_COMMONSEPARATOR, /* : -  58 */
 903   C2_OTHERNEUTRAL, /* ; -  59 */
 904   C2_OTHERNEUTRAL, /* < -  60 */
 905   C2_OTHERNEUTRAL, /* = -  61 */
 906   C2_OTHERNEUTRAL, /* > -  62 */
 907   C2_OTHERNEUTRAL, /* ? -  63 */
 908   C2_LEFTTORIGHT, /* @ -  64 */
 909   C2_LEFTTORIGHT, /* A -  65 */
 910   C2_LEFTTORIGHT, /* B -  66 */
 911   C2_LEFTTORIGHT, /* C -  67 */
 912   C2_LEFTTORIGHT, /* D -  68 */
 913   C2_LEFTTORIGHT, /* E -  69 */
 914   C2_LEFTTORIGHT, /* F -  70 */
 915   C2_LEFTTORIGHT, /* G -  71 */
 916   C2_LEFTTORIGHT, /* H -  72 */
 917   C2_LEFTTORIGHT, /* I -  73 */
 918   C2_LEFTTORIGHT, /* J -  74 */
 919   C2_LEFTTORIGHT, /* K -  75 */
 920   C2_LEFTTORIGHT, /* L -  76 */
 921   C2_LEFTTORIGHT, /* M -  77 */
 922   C2_LEFTTORIGHT, /* N -  78 */
 923   C2_LEFTTORIGHT, /* O -  79 */
 924   C2_LEFTTORIGHT, /* P -  80 */
 925   C2_LEFTTORIGHT, /* Q -  81 */
 926   C2_LEFTTORIGHT, /* R -  82 */
 927   C2_LEFTTORIGHT, /* S -  83 */
 928   C2_LEFTTORIGHT, /* T -  84 */
 929   C2_LEFTTORIGHT, /* U -  85 */
 930   C2_LEFTTORIGHT, /* V -  86 */
 931   C2_LEFTTORIGHT, /* W -  87 */
 932   C2_LEFTTORIGHT, /* X -  88 */
 933   C2_LEFTTORIGHT, /* Y -  89 */
 934   C2_LEFTTORIGHT, /* Z -  90 */
 935   C2_OTHERNEUTRAL, /* [ -  91 */
 936   C2_OTHERNEUTRAL, /* \ -  92 */
 937   C2_OTHERNEUTRAL, /* ] -  93 */
 938   C2_OTHERNEUTRAL, /* ^ -  94 */
 939   C2_OTHERNEUTRAL, /* _ -  95 */
 940   C2_OTHERNEUTRAL, /* ` -  96 */
 941   C2_LEFTTORIGHT, /* a -  97 */
 942   C2_LEFTTORIGHT, /* b -  98 */
 943   C2_LEFTTORIGHT, /* c -  99 */
 944   C2_LEFTTORIGHT, /* d - 100 */
 945   C2_LEFTTORIGHT, /* e - 101 */
 946   C2_LEFTTORIGHT, /* f - 102 */
 947   C2_LEFTTORIGHT, /* g - 103 */
 948   C2_LEFTTORIGHT, /* h - 104 */
 949   C2_LEFTTORIGHT, /* i - 105 */
 950   C2_LEFTTORIGHT, /* j - 106 */
 951   C2_LEFTTORIGHT, /* k - 107 */
 952   C2_LEFTTORIGHT, /* l - 108 */
 953   C2_LEFTTORIGHT, /* m - 109 */
 954   C2_LEFTTORIGHT, /* n - 110 */
 955   C2_LEFTTORIGHT, /* o - 111 */
 956   C2_LEFTTORIGHT, /* p - 112 */
 957   C2_LEFTTORIGHT, /* q - 113 */
 958   C2_LEFTTORIGHT, /* r - 114 */
 959   C2_LEFTTORIGHT, /* s - 115 */
 960   C2_LEFTTORIGHT, /* t - 116 */
 961   C2_LEFTTORIGHT, /* u - 117 */
 962   C2_LEFTTORIGHT, /* v - 118 */
 963   C2_LEFTTORIGHT, /* w - 119 */
 964   C2_LEFTTORIGHT, /* x - 120 */
 965   C2_LEFTTORIGHT, /* y - 121 */
 966   C2_LEFTTORIGHT, /* z - 122 */
 967   C2_OTHERNEUTRAL, /* { - 123 */
 968   C2_OTHERNEUTRAL, /* | - 124 */
 969   C2_OTHERNEUTRAL, /* } - 125 */
 970   C2_OTHERNEUTRAL, /* ~ - 126 */
 971   C2_NOTAPPLICABLE, /* \7f - 127 */
 972   C2_NOTAPPLICABLE, /* \80 - 128 */
 973   C2_NOTAPPLICABLE, /* \81 - 129 */
 974   C2_OTHERNEUTRAL, /* \82 - 130 */
 975   C2_LEFTTORIGHT, /* \83 - 131 */
 976   C2_OTHERNEUTRAL, /* \84 - 132 */
 977   C2_OTHERNEUTRAL, /* \85 - 133 */
 978   C2_OTHERNEUTRAL, /* \86 - 134 */
 979   C2_OTHERNEUTRAL, /* \87 - 135 */
 980   C2_LEFTTORIGHT, /* \88 - 136 */
 981   C2_EUROPETERMINATOR, /* \89 - 137 */
 982   C2_LEFTTORIGHT, /* \8a - 138 */
 983   C2_OTHERNEUTRAL, /* \8b - 139 */
 984   C2_LEFTTORIGHT, /* \8c - 140 */
 985   C2_NOTAPPLICABLE, /* \8d - 141 */
 986   C2_NOTAPPLICABLE, /* \8e - 142 */
 987   C2_NOTAPPLICABLE, /* \8f - 143 */
 988   C2_NOTAPPLICABLE, /* \90 - 144 */
 989   C2_OTHERNEUTRAL, /* \91 - 145 */
 990   C2_OTHERNEUTRAL, /* \92 - 146 */
 991   C2_OTHERNEUTRAL, /* \93 - 147 */
 992   C2_OTHERNEUTRAL, /* \94 - 148 */
 993   C2_OTHERNEUTRAL, /* \95 - 149 */
 994   C2_OTHERNEUTRAL, /* \96 - 150 */
 995   C2_OTHERNEUTRAL, /* \97 - 151 */
 996   C2_LEFTTORIGHT, /* \98 - 152 */
 997   C2_OTHERNEUTRAL, /* \99 - 153 */
 998   C2_LEFTTORIGHT, /* \9a - 154 */
 999   C2_OTHERNEUTRAL, /* \9b - 155 */
1000   C2_LEFTTORIGHT, /* \9c - 156 */
1001   C2_NOTAPPLICABLE, /* \9d - 157 */
1002   C2_NOTAPPLICABLE, /* \9e - 158 */
1003   C2_LEFTTORIGHT, /* \9f - 159 */
1004   C2_WHITESPACE, /*   - 160 */
1005   C2_OTHERNEUTRAL, /* ¡ - 161 */
1006   C2_EUROPETERMINATOR, /* ¢ - 162 */
1007   C2_EUROPETERMINATOR, /* £ - 163 */
1008   C2_EUROPETERMINATOR, /* ¤ - 164 */
1009   C2_EUROPETERMINATOR, /* ¥ - 165 */
1010   C2_OTHERNEUTRAL, /* ¦ - 166 */
1011   C2_OTHERNEUTRAL, /* § - 167 */
1012   C2_OTHERNEUTRAL, /* ¨ - 168 */
1013   C2_OTHERNEUTRAL, /* © - 169 */
1014   C2_OTHERNEUTRAL, /* ª - 170 */
1015   C2_OTHERNEUTRAL, /* « - 171 */
1016   C2_OTHERNEUTRAL, /* ¬ - 172 */
1017   C2_OTHERNEUTRAL, /*  - 173 */
1018   C2_OTHERNEUTRAL, /* ® - 174 */
1019   C2_OTHERNEUTRAL, /* ¯ - 175 */
1020   C2_EUROPETERMINATOR, /* ° - 176 */
1021   C2_EUROPETERMINATOR, /* ± - 177 */
1022   C2_EUROPENUMBER, /* ² - 178 */
1023   C2_EUROPENUMBER, /* ³ - 179 */
1024   C2_OTHERNEUTRAL, /* ´ - 180 */
1025   C2_OTHERNEUTRAL, /* µ - 181 */
1026   C2_OTHERNEUTRAL, /* ¶ - 182 */
1027   C2_OTHERNEUTRAL, /* · - 183 */
1028   C2_OTHERNEUTRAL, /* ¸ - 184 */
1029   C2_EUROPENUMBER, /* ¹ - 185 */
1030   C2_OTHERNEUTRAL, /* º - 186 */
1031   C2_OTHERNEUTRAL, /* » - 187 */
1032   C2_OTHERNEUTRAL, /* ¼ - 188 */
1033   C2_OTHERNEUTRAL, /* ½ - 189 */
1034   C2_OTHERNEUTRAL, /* ¾ - 190 */
1035   C2_OTHERNEUTRAL, /* ¿ - 191 */
1036   C2_LEFTTORIGHT, /* À - 192 */
1037   C2_LEFTTORIGHT, /* Á - 193 */
1038   C2_LEFTTORIGHT, /* Â - 194 */
1039   C2_LEFTTORIGHT, /* Ã - 195 */
1040   C2_LEFTTORIGHT, /* Ä - 196 */
1041   C2_LEFTTORIGHT, /* Å - 197 */
1042   C2_LEFTTORIGHT, /* Æ - 198 */
1043   C2_LEFTTORIGHT, /* Ç - 199 */
1044   C2_LEFTTORIGHT, /* È - 200 */
1045   C2_LEFTTORIGHT, /* É - 201 */
1046   C2_LEFTTORIGHT, /* Ê - 202 */
1047   C2_LEFTTORIGHT, /* Ë - 203 */
1048   C2_LEFTTORIGHT, /* Ì - 204 */
1049   C2_LEFTTORIGHT, /* Í - 205 */
1050   C2_LEFTTORIGHT, /* Î - 206 */
1051   C2_LEFTTORIGHT, /* Ï - 207 */
1052   C2_LEFTTORIGHT, /* Ð - 208 */
1053   C2_LEFTTORIGHT, /* Ñ - 209 */
1054   C2_LEFTTORIGHT, /* Ò - 210 */
1055   C2_LEFTTORIGHT, /* Ó - 211 */
1056   C2_LEFTTORIGHT, /* Ô - 212 */
1057   C2_LEFTTORIGHT, /* Õ - 213 */
1058   C2_LEFTTORIGHT, /* Ö - 214 */
1059   C2_OTHERNEUTRAL, /* × - 215 */
1060   C2_LEFTTORIGHT, /* Ø - 216 */
1061   C2_LEFTTORIGHT, /* Ù - 217 */
1062   C2_LEFTTORIGHT, /* Ú - 218 */
1063   C2_LEFTTORIGHT, /* Û - 219 */
1064   C2_LEFTTORIGHT, /* Ü - 220 */
1065   C2_LEFTTORIGHT, /* Ý - 221 */
1066   C2_LEFTTORIGHT, /* Þ - 222 */
1067   C2_LEFTTORIGHT, /* ß - 223 */
1068   C2_LEFTTORIGHT, /* à - 224 */
1069   C2_LEFTTORIGHT, /* á - 225 */
1070   C2_LEFTTORIGHT, /* â - 226 */
1071   C2_LEFTTORIGHT, /* ã - 227 */
1072   C2_LEFTTORIGHT, /* ä - 228 */
1073   C2_LEFTTORIGHT, /* å - 229 */
1074   C2_LEFTTORIGHT, /* æ - 230 */
1075   C2_LEFTTORIGHT, /* ç - 231 */
1076   C2_LEFTTORIGHT, /* è - 232 */
1077   C2_LEFTTORIGHT, /* é - 233 */
1078   C2_LEFTTORIGHT, /* ê - 234 */
1079   C2_LEFTTORIGHT, /* ë - 235 */
1080   C2_LEFTTORIGHT, /* ì - 236 */
1081   C2_LEFTTORIGHT, /* í - 237 */
1082   C2_LEFTTORIGHT, /* î - 238 */
1083   C2_LEFTTORIGHT, /* ï - 239 */
1084   C2_LEFTTORIGHT, /* ð - 240 */
1085   C2_LEFTTORIGHT, /* ñ - 241 */
1086   C2_LEFTTORIGHT, /* ò - 242 */
1087   C2_LEFTTORIGHT, /* ó - 243 */
1088   C2_LEFTTORIGHT, /* ô - 244 */
1089   C2_LEFTTORIGHT, /* õ - 245 */
1090   C2_LEFTTORIGHT, /* ö - 246 */
1091   C2_OTHERNEUTRAL, /* ÷ - 247 */
1092   C2_LEFTTORIGHT, /* ø - 248 */
1093   C2_LEFTTORIGHT, /* ù - 249 */
1094   C2_LEFTTORIGHT, /* ú - 250 */
1095   C2_LEFTTORIGHT, /* û - 251 */
1096   C2_LEFTTORIGHT, /* ü - 252 */
1097   C2_LEFTTORIGHT, /* ý - 253 */
1098   C2_LEFTTORIGHT, /* þ - 254 */
1099   C2_LEFTTORIGHT /* ÿ - 255 */
1100 };
1101
1102 static const WORD CT_CType3_LUT[] = {
1103   0x0000, /*   -   0 */
1104   0x0000, /*   -   1 */
1105   0x0000, /*   -   2 */
1106   0x0000, /*   -   3 */
1107   0x0000, /*   -   4 */
1108   0x0000, /*   -   5 */
1109   0x0000, /*   -   6 */
1110   0x0000, /*   -   7 */
1111   0x0000, /*   -   8 */
1112   0x0008, /*   -   9 */
1113   0x0008, /*   -  10 */
1114   0x0008, /*   -  11 */
1115   0x0008, /*   -  12 */
1116   0x0008, /*   -  13 */
1117   0x0000, /*   -  14 */
1118   0x0000, /*   -  15 */
1119   0x0000, /*   -  16 */
1120   0x0000, /*   -  17 */
1121   0x0000, /*   -  18 */
1122   0x0000, /*   -  19 */
1123   0x0000, /*   -  20 */
1124   0x0000, /*   -  21 */
1125   0x0000, /*   -  22 */
1126   0x0000, /*   -  23 */
1127   0x0000, /*   -  24 */
1128   0x0000, /*   -  25 */
1129   0x0000, /*   -  26 */
1130   0x0000, /*   -  27 */
1131   0x0000, /*   -  28 */
1132   0x0000, /*   -  29 */
1133   0x0000, /*   -  30 */
1134   0x0000, /*   -  31 */
1135   0x0048, /*   -  32 */
1136   0x0048, /* ! -  33 */
1137   0x0448, /* " -  34 */ /* " */
1138   0x0048, /* # -  35 */
1139   0x0448, /* $ -  36 */
1140   0x0048, /* % -  37 */
1141   0x0048, /* & -  38 */
1142   0x0440, /* ' -  39 */
1143   0x0048, /* ( -  40 */
1144   0x0048, /* ) -  41 */
1145   0x0048, /* * -  42 */
1146   0x0048, /* + -  43 */
1147   0x0048, /* , -  44 */
1148   0x0440, /* - -  45 */
1149   0x0048, /* . -  46 */
1150   0x0448, /* / -  47 */
1151   0x0040, /* 0 -  48 */
1152   0x0040, /* 1 -  49 */
1153   0x0040, /* 2 -  50 */
1154   0x0040, /* 3 -  51 */
1155   0x0040, /* 4 -  52 */
1156   0x0040, /* 5 -  53 */
1157   0x0040, /* 6 -  54 */
1158   0x0040, /* 7 -  55 */
1159   0x0040, /* 8 -  56 */
1160   0x0040, /* 9 -  57 */
1161   0x0048, /* : -  58 */
1162   0x0048, /* ; -  59 */
1163   0x0048, /* < -  60 */
1164   0x0448, /* = -  61 */
1165   0x0048, /* > -  62 */
1166   0x0048, /* ? -  63 */
1167   0x0448, /* @ -  64 */
1168   0x8040, /* A -  65 */
1169   0x8040, /* B -  66 */
1170   0x8040, /* C -  67 */
1171   0x8040, /* D -  68 */
1172   0x8040, /* E -  69 */
1173   0x8040, /* F -  70 */
1174   0x8040, /* G -  71 */
1175   0x8040, /* H -  72 */
1176   0x8040, /* I -  73 */
1177   0x8040, /* J -  74 */
1178   0x8040, /* K -  75 */
1179   0x8040, /* L -  76 */
1180   0x8040, /* M -  77 */
1181   0x8040, /* N -  78 */
1182   0x8040, /* O -  79 */
1183   0x8040, /* P -  80 */
1184   0x8040, /* Q -  81 */
1185   0x8040, /* R -  82 */
1186   0x8040, /* S -  83 */
1187   0x8040, /* T -  84 */
1188   0x8040, /* U -  85 */
1189   0x8040, /* V -  86 */
1190   0x8040, /* W -  87 */
1191   0x8040, /* X -  88 */
1192   0x8040, /* Y -  89 */
1193   0x8040, /* Z -  90 */
1194   0x0048, /* [ -  91 */
1195   0x0448, /* \ -  92 */
1196   0x0048, /* ] -  93 */
1197   0x0448, /* ^ -  94 */
1198   0x0448, /* _ -  95 */
1199   0x0448, /* ` -  96 */
1200   0x8040, /* a -  97 */
1201   0x8040, /* b -  98 */
1202   0x8040, /* c -  99 */
1203   0x8040, /* d - 100 */
1204   0x8040, /* e - 101 */
1205   0x8040, /* f - 102 */
1206   0x8040, /* g - 103 */
1207   0x8040, /* h - 104 */
1208   0x8040, /* i - 105 */
1209   0x8040, /* j - 106 */
1210   0x8040, /* k - 107 */
1211   0x8040, /* l - 108 */
1212   0x8040, /* m - 109 */
1213   0x8040, /* n - 110 */
1214   0x8040, /* o - 111 */
1215   0x8040, /* p - 112 */
1216   0x8040, /* q - 113 */
1217   0x8040, /* r - 114 */
1218   0x8040, /* s - 115 */
1219   0x8040, /* t - 116 */
1220   0x8040, /* u - 117 */
1221   0x8040, /* v - 118 */
1222   0x8040, /* w - 119 */
1223   0x8040, /* x - 120 */
1224   0x8040, /* y - 121 */
1225   0x8040, /* z - 122 */
1226   0x0048, /* { - 123 */
1227   0x0048, /* | - 124 */
1228   0x0048, /* } - 125 */
1229   0x0448, /* ~ - 126 */
1230   0x0000, /* \7f - 127 */
1231   0x0000, /* \80 - 128 */
1232   0x0000, /* \81 - 129 */
1233   0x0008, /* \82 - 130 */
1234   0x8000, /* \83 - 131 */
1235   0x0008, /* \84 - 132 */
1236   0x0008, /* \85 - 133 */
1237   0x0008, /* \86 - 134 */
1238   0x0008, /* \87 - 135 */
1239   0x0001, /* \88 - 136 */
1240   0x0008, /* \89 - 137 */
1241   0x8003, /* \8a - 138 */
1242   0x0008, /* \8b - 139 */
1243   0x8000, /* \8c - 140 */
1244   0x0000, /* \8d - 141 */
1245   0x0000, /* \8e - 142 */
1246   0x0000, /* \8f - 143 */
1247   0x0000, /* \90 - 144 */
1248   0x0088, /* \91 - 145 */
1249   0x0088, /* \92 - 146 */
1250   0x0088, /* \93 - 147 */
1251   0x0088, /* \94 - 148 */
1252   0x0008, /* \95 - 149 */
1253   0x0400, /* \96 - 150 */
1254   0x0400, /* \97 - 151 */
1255   0x0408, /* \98 - 152 */
1256   0x0000, /* \99 - 153 */
1257   0x8003, /* \9a - 154 */
1258   0x0008, /* \9b - 155 */
1259   0x8000, /* \9c - 156 */
1260   0x0000, /* \9d - 157 */
1261   0x0000, /* \9e - 158 */
1262   0x8003, /* \9f - 159 */
1263   0x0008, /*   - 160 */
1264   0x0008, /* ¡ - 161 */
1265   0x0048, /* ¢ - 162 */
1266   0x0048, /* £ - 163 */
1267   0x0008, /* ¤ - 164 */
1268   0x0048, /* ¥ - 165 */
1269   0x0048, /* ¦ - 166 */
1270   0x0008, /* § - 167 */
1271   0x0408, /* ¨ - 168 */
1272   0x0008, /* © - 169 */
1273   0x0400, /* ª - 170 */
1274   0x0008, /* « - 171 */
1275   0x0048, /* ¬ - 172 */
1276   0x0408, /*  - 173 */
1277   0x0008, /* ® - 174 */
1278   0x0448, /* ¯ - 175 */
1279   0x0008, /* ° - 176 */
1280   0x0008, /* ± - 177 */
1281   0x0000, /* ² - 178 */
1282   0x0000, /* ³ - 179 */
1283   0x0408, /* ´ - 180 */
1284   0x0008, /* µ - 181 */
1285   0x0008, /* ¶ - 182 */
1286   0x0008, /* · - 183 */
1287   0x0408, /* ¸ - 184 */
1288   0x0000, /* ¹ - 185 */
1289   0x0400, /* º - 186 */
1290   0x0008, /* » - 187 */
1291   0x0000, /* ¼ - 188 */
1292   0x0000, /* ½ - 189 */
1293   0x0000, /* ¾ - 190 */
1294   0x0008, /* ¿ - 191 */
1295   0x8003, /* À - 192 */
1296   0x8003, /* Á - 193 */
1297   0x8003, /* Â - 194 */
1298   0x8003, /* Ã - 195 */
1299   0x8003, /* Ä - 196 */
1300   0x8003, /* Å - 197 */
1301   0x8000, /* Æ - 198 */
1302   0x8003, /* Ç - 199 */
1303   0x8003, /* È - 200 */
1304   0x8003, /* É - 201 */
1305   0x8003, /* Ê - 202 */
1306   0x8003, /* Ë - 203 */
1307   0x8003, /* Ì - 204 */
1308   0x8003, /* Í - 205 */
1309   0x8003, /* Î - 206 */
1310   0x8003, /* Ï - 207 */
1311   0x8000, /* Ð - 208 */
1312   0x8003, /* Ñ - 209 */
1313   0x8003, /* Ò - 210 */
1314   0x8003, /* Ó - 211 */
1315   0x8003, /* Ô - 212 */
1316   0x8003, /* Õ - 213 */
1317   0x8003, /* Ö - 214 */
1318   0x0008, /* × - 215 */
1319   0x8003, /* Ø - 216 */
1320   0x8003, /* Ù - 217 */
1321   0x8003, /* Ú - 218 */
1322   0x8003, /* Û - 219 */
1323   0x8003, /* Ü - 220 */
1324   0x8003, /* Ý - 221 */
1325   0x8000, /* Þ - 222 */
1326   0x8000, /* ß - 223 */
1327   0x8003, /* à - 224 */
1328   0x8003, /* á - 225 */
1329   0x8003, /* â - 226 */
1330   0x8003, /* ã - 227 */
1331   0x8003, /* ä - 228 */
1332   0x8003, /* å - 229 */
1333   0x8000, /* æ - 230 */
1334   0x8003, /* ç - 231 */
1335   0x8003, /* è - 232 */
1336   0x8003, /* é - 233 */
1337   0x8003, /* ê - 234 */
1338   0x8003, /* ë - 235 */
1339   0x8003, /* ì - 236 */
1340   0x8003, /* í - 237 */
1341   0x8003, /* î - 238 */
1342   0x8003, /* ï - 239 */
1343   0x8000, /* ð - 240 */
1344   0x8003, /* ñ - 241 */
1345   0x8003, /* ò - 242 */
1346   0x8003, /* ó - 243 */
1347   0x8003, /* ô - 244 */
1348   0x8003, /* õ - 245 */
1349   0x8003, /* ö - 246 */
1350   0x0008, /* ÷ - 247 */
1351   0x8003, /* ø - 248 */
1352   0x8003, /* ù - 249 */
1353   0x8003, /* ú - 250 */
1354   0x8003, /* û - 251 */
1355   0x8003, /* ü - 252 */
1356   0x8003, /* ý - 253 */
1357   0x8000, /* þ - 254 */
1358   0x8003  /* ÿ - 255 */
1359 };
1360
1361 /******************************************************************************
1362  *              GetStringType16 [OLE2NLS.7]
1363  */
1364 BOOL16 WINAPI GetStringType16(LCID locale,DWORD dwInfoType,LPCSTR src,
1365                               INT16 cchSrc,LPWORD chartype)
1366 {
1367         return GetStringTypeEx32A(locale,dwInfoType,src,cchSrc,chartype);
1368 }
1369 /******************************************************************************
1370  *              GetStringType32A        [KERNEL32.396]
1371  */
1372 BOOL32 WINAPI GetStringType32A(LCID locale,DWORD dwInfoType,LPCSTR src,
1373                                INT32 cchSrc,LPWORD chartype)
1374 {
1375         return GetStringTypeEx32A(locale,dwInfoType,src,cchSrc,chartype);
1376 }
1377
1378 /******************************************************************************
1379  *              GetStringTypeEx32A      [KERNEL32.397]
1380  *
1381  * FIXME: Ignores the locale.
1382  */
1383 BOOL32 WINAPI GetStringTypeEx32A(LCID locale,DWORD dwInfoType,LPCSTR src,
1384                                  INT32 cchSrc,LPWORD chartype)
1385 {
1386         int     i;
1387
1388         if ((src==NULL) || (chartype==NULL) || (src==(LPSTR)chartype))
1389         {
1390           SetLastError(ERROR_INVALID_PARAMETER);
1391           return FALSE;
1392         }
1393
1394         if (cchSrc==-1)
1395           cchSrc=lstrlen32A(src)+1;
1396
1397         switch (dwInfoType) {
1398         case CT_CTYPE1:
1399           for (i=0;i<cchSrc;i++)
1400           {
1401             chartype[i] = 0;
1402             if (isdigit(src[i])) chartype[i]|=C1_DIGIT;
1403             if (isalpha(src[i])) chartype[i]|=C1_ALPHA;
1404             if (islower(src[i])) chartype[i]|=C1_LOWER;
1405             if (isupper(src[i])) chartype[i]|=C1_UPPER;
1406             if (isspace(src[i])) chartype[i]|=C1_SPACE;
1407             if (ispunct(src[i])) chartype[i]|=C1_PUNCT;
1408             if (iscntrl(src[i])) chartype[i]|=C1_CNTRL;
1409 /* FIXME: isblank() is a GNU extension */
1410 /*              if (isblank(src[i])) chartype[i]|=C1_BLANK; */
1411             if ((src[i] == ' ') || (src[i] == '\t')) chartype[i]|=C1_BLANK;
1412             /* C1_XDIGIT */
1413         }
1414         return TRUE;
1415
1416         case CT_CTYPE2:
1417           for (i=0;i<cchSrc;i++)
1418           {
1419             chartype[i]=(WORD)CT_CType2_LUT[i];
1420           }
1421           return TRUE;
1422
1423         case CT_CTYPE3:
1424           for (i=0;i<cchSrc;i++)
1425           {
1426             chartype[i]=CT_CType3_LUT[i];
1427           }
1428           return TRUE;
1429
1430         default:
1431           ERR(ole,"Unknown dwInfoType:%ld\n",dwInfoType);
1432           return FALSE;
1433         }
1434 }
1435
1436 /******************************************************************************
1437  *              GetStringType32W        [KERNEL32.399]
1438  *
1439  * NOTES
1440  * Yes, this is missing LCID locale. MS fault.
1441  */
1442 BOOL32 WINAPI GetStringType32W(DWORD dwInfoType,LPCWSTR src,INT32 cchSrc,
1443                                LPWORD chartype)
1444 {
1445         return GetStringTypeEx32W(0/*defaultlocale*/,dwInfoType,src,cchSrc,chartype);
1446 }
1447
1448 /******************************************************************************
1449  *              GetStringTypeEx32W      [KERNEL32.398]
1450  *
1451  * FIXME: unicode chars are assumed chars
1452  */
1453 BOOL32 WINAPI GetStringTypeEx32W(LCID locale,DWORD dwInfoType,LPCWSTR src,
1454                                  INT32 cchSrc,LPWORD chartype)
1455 {
1456         int     i;
1457
1458
1459         if (cchSrc==-1)
1460           cchSrc=lstrlen32W(src)+1;
1461
1462         switch (dwInfoType) {
1463         case CT_CTYPE2:
1464                 FIXME(ole,"CT_CTYPE2 not supported.\n");
1465                 return FALSE;
1466         case CT_CTYPE3:
1467                 FIXME(ole,"CT_CTYPE3 not supported.\n");
1468                 return FALSE;
1469         default:break;
1470         }
1471         for (i=0;i<cchSrc;i++) {
1472                 chartype[i] = 0;
1473                 if (isdigit(src[i])) chartype[i]|=C1_DIGIT;
1474                 if (isalpha(src[i])) chartype[i]|=C1_ALPHA;
1475                 if (islower(src[i])) chartype[i]|=C1_LOWER;
1476                 if (isupper(src[i])) chartype[i]|=C1_UPPER;
1477                 if (isspace(src[i])) chartype[i]|=C1_SPACE;
1478                 if (ispunct(src[i])) chartype[i]|=C1_PUNCT;
1479                 if (iscntrl(src[i])) chartype[i]|=C1_CNTRL;
1480 /* FIXME: isblank() is a GNU extension */
1481 /*              if (isblank(src[i])) chartype[i]|=C1_BLANK; */
1482                 if ((src[i] == ' ') || (src[i] == '\t')) chartype[i]|=C1_BLANK;
1483                 /* C1_XDIGIT */
1484         }
1485         return TRUE;
1486 }
1487
1488 /*****************************************************************
1489  * VerLanguageName16   [VER.10]
1490  */
1491 DWORD WINAPI VerLanguageName16(UINT16 langid,LPSTR langname,UINT16 langnamelen)
1492 {
1493         int     i;
1494         DWORD   result;
1495         char    buffer[80];
1496
1497         TRACE(ver,"(%d,%p,%d)\n",langid,langname,langnamelen);
1498         /* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
1499          * from the registry.
1500          */
1501         sprintf(buffer,
1502                 "\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",
1503                 langid);
1504         result = RegQueryValue16(HKEY_LOCAL_MACHINE, buffer, langname,
1505                                 (LPDWORD)&langnamelen);
1506         if (result == ERROR_SUCCESS) {
1507                 langname[langnamelen-1]='\0';
1508                 return langnamelen;
1509         }
1510         /* if that fails, use the internal table */
1511         for (i=0;languages[i].langid!=0;i++)
1512                 if (langid==languages[i].langid)
1513                         break;
1514         strncpy(langname,languages[i].langname,langnamelen);
1515         langname[langnamelen-1]='\0';
1516         return strlen(languages[i].langname);
1517 }
1518
1519 /*****************************************************************
1520  * VerLanguageName32A                           [VERSION.9]
1521  */
1522 DWORD WINAPI VerLanguageName32A(UINT32 langid,LPSTR langname,
1523                                 UINT32 langnamelen)
1524 {
1525         return VerLanguageName16(langid,langname,langnamelen);
1526 }
1527
1528 /*****************************************************************
1529  * VerLanguageName32W                           [VERSION.10]
1530  */
1531 DWORD WINAPI VerLanguageName32W(UINT32 langid,LPWSTR langname,
1532                                 UINT32 langnamelen)
1533 {
1534         int     i;
1535         LPWSTR  keyname;
1536         DWORD   result;
1537         char    buffer[80];
1538
1539         /* First, check \System\CurrentControlSet\control\Nls\Locale\<langid>
1540          * from the registry.
1541          */
1542         sprintf(buffer,
1543                 "\\System\\CurrentControlSet\\control\\Nls\\Locale\\%08x",
1544                 langid);
1545         keyname = HEAP_strdupAtoW( GetProcessHeap(), 0, buffer );
1546         result = RegQueryValue32W(HKEY_LOCAL_MACHINE, keyname, langname,
1547                                 (LPDWORD)&langnamelen);
1548         HeapFree( GetProcessHeap(), 0, keyname );
1549         if (result != ERROR_SUCCESS) {
1550                 /* if that fails, use the internal table */
1551                 for (i=0;languages[i].langid!=0;i++)
1552                         if (langid==languages[i].langid)
1553                                 break;
1554                 lstrcpyAtoW( langname, languages[i].langname );
1555                 langnamelen = strlen(languages[i].langname);
1556                 /* same as strlenW(langname); */
1557         }
1558         return langnamelen;
1559 }
1560
1561 static const unsigned char LCM_Unicode_LUT[] = {
1562   6      ,   3, /*   -   1 */
1563   6      ,   4, /*   -   2 */
1564   6      ,   5, /*   -   3 */
1565   6      ,   6, /*   -   4 */
1566   6      ,   7, /*   -   5 */
1567   6      ,   8, /*   -   6 */
1568   6      ,   9, /*   -   7 */
1569   6      ,  10, /*   -   8 */
1570   7      ,   5, /*   -   9 */
1571   7      ,   6, /*   -  10 */
1572   7      ,   7, /*   -  11 */
1573   7      ,   8, /*   -  12 */
1574   7      ,   9, /*   -  13 */
1575   6      ,  11, /*   -  14 */
1576   6      ,  12, /*   -  15 */
1577   6      ,  13, /*   -  16 */
1578   6      ,  14, /*   -  17 */
1579   6      ,  15, /*   -  18 */
1580   6      ,  16, /*   -  19 */
1581   6      ,  17, /*   -  20 */
1582   6      ,  18, /*   -  21 */
1583   6      ,  19, /*   -  22 */
1584   6      ,  20, /*   -  23 */
1585   6      ,  21, /*   -  24 */
1586   6      ,  22, /*   -  25 */
1587   6      ,  23, /*   -  26 */
1588   6      ,  24, /*   -  27 */
1589   6      ,  25, /*   -  28 */
1590   6      ,  26, /*   -  29 */
1591   6      ,  27, /*   -  30 */
1592   6      ,  28, /*   -  31 */
1593   7      ,   2, /*   -  32 */
1594   7      ,  28, /* ! -  33 */
1595   7      ,  29, /* " -  34 */ /* " */
1596   7      ,  31, /* # -  35 */
1597   7      ,  33, /* $ -  36 */
1598   7      ,  35, /* % -  37 */
1599   7      ,  37, /* & -  38 */
1600   6      , 128, /* ' -  39 */
1601   7      ,  39, /* ( -  40 */
1602   7      ,  42, /* ) -  41 */
1603   7      ,  45, /* * -  42 */
1604   8      ,   3, /* + -  43 */
1605   7      ,  47, /* , -  44 */
1606   6      , 130, /* - -  45 */
1607   7      ,  51, /* . -  46 */
1608   7      ,  53, /* / -  47 */
1609  12      ,   3, /* 0 -  48 */
1610  12      ,  33, /* 1 -  49 */
1611  12      ,  51, /* 2 -  50 */
1612  12      ,  70, /* 3 -  51 */
1613  12      ,  88, /* 4 -  52 */
1614  12      , 106, /* 5 -  53 */
1615  12      , 125, /* 6 -  54 */
1616  12      , 144, /* 7 -  55 */
1617  12      , 162, /* 8 -  56 */
1618  12      , 180, /* 9 -  57 */
1619   7      ,  55, /* : -  58 */
1620   7      ,  58, /* ; -  59 */
1621   8      ,  14, /* < -  60 */
1622   8      ,  18, /* = -  61 */
1623   8      ,  20, /* > -  62 */
1624   7      ,  60, /* ? -  63 */
1625   7      ,  62, /* @ -  64 */
1626  14      ,   2, /* A -  65 */
1627  14      ,   9, /* B -  66 */
1628  14      ,  10, /* C -  67 */
1629  14      ,  26, /* D -  68 */
1630  14      ,  33, /* E -  69 */
1631  14      ,  35, /* F -  70 */
1632  14      ,  37, /* G -  71 */
1633  14      ,  44, /* H -  72 */
1634  14      ,  50, /* I -  73 */
1635  14      ,  53, /* J -  74 */
1636  14      ,  54, /* K -  75 */
1637  14      ,  72, /* L -  76 */
1638  14      ,  81, /* M -  77 */
1639  14      , 112, /* N -  78 */
1640  14      , 124, /* O -  79 */
1641  14      , 126, /* P -  80 */
1642  14      , 137, /* Q -  81 */
1643  14      , 138, /* R -  82 */
1644  14      , 145, /* S -  83 */
1645  14      , 153, /* T -  84 */
1646  14      , 159, /* U -  85 */
1647  14      , 162, /* V -  86 */
1648  14      , 164, /* W -  87 */
1649  14      , 166, /* X -  88 */
1650  14      , 167, /* Y -  89 */
1651  14      , 169, /* Z -  90 */
1652   7      ,  63, /* [ -  91 */
1653   7      ,  65, /* \ -  92 */
1654   7      ,  66, /* ] -  93 */
1655   7      ,  67, /* ^ -  94 */
1656   7      ,  68, /* _ -  95 */
1657   7      ,  72, /* ` -  96 */
1658  14      ,   2, /* a -  97 */
1659  14      ,   9, /* b -  98 */
1660  14      ,  10, /* c -  99 */
1661  14      ,  26, /* d - 100 */
1662  14      ,  33, /* e - 101 */
1663  14      ,  35, /* f - 102 */
1664  14      ,  37, /* g - 103 */
1665  14      ,  44, /* h - 104 */
1666  14      ,  50, /* i - 105 */
1667  14      ,  53, /* j - 106 */
1668  14      ,  54, /* k - 107 */
1669  14      ,  72, /* l - 108 */
1670  14      ,  81, /* m - 109 */
1671  14      , 112, /* n - 110 */
1672  14      , 124, /* o - 111 */
1673  14      , 126, /* p - 112 */
1674  14      , 137, /* q - 113 */
1675  14      , 138, /* r - 114 */
1676  14      , 145, /* s - 115 */
1677  14      , 153, /* t - 116 */
1678  14      , 159, /* u - 117 */
1679  14      , 162, /* v - 118 */
1680  14      , 164, /* w - 119 */
1681  14      , 166, /* x - 120 */
1682  14      , 167, /* y - 121 */
1683  14      , 169, /* z - 122 */
1684   7      ,  74, /* { - 123 */
1685   7      ,  76, /* | - 124 */
1686   7      ,  78, /* } - 125 */
1687   7      ,  80, /* ~ - 126 */
1688   6      ,  29, /* \7f - 127 */
1689   6      ,  30, /* \80 - 128 */
1690   6      ,  31, /* \81 - 129 */
1691   7      , 123, /* \82 - 130 */
1692  14      ,  35, /* \83 - 131 */
1693   7      , 127, /* \84 - 132 */
1694  10      ,  21, /* \85 - 133 */
1695  10      ,  15, /* \86 - 134 */
1696  10      ,  16, /* \87 - 135 */
1697   7      ,  67, /* \88 - 136 */
1698  10      ,  22, /* \89 - 137 */
1699  14      , 145, /* \8a - 138 */
1700   7      , 136, /* \8b - 139 */
1701  14 + 16 , 124, /* \8c - 140 */
1702   6      ,  43, /* \8d - 141 */
1703   6      ,  44, /* \8e - 142 */
1704   6      ,  45, /* \8f - 143 */
1705   6      ,  46, /* \90 - 144 */
1706   7      , 121, /* \91 - 145 */
1707   7      , 122, /* \92 - 146 */
1708   7      , 125, /* \93 - 147 */
1709   7      , 126, /* \94 - 148 */
1710  10      ,  17, /* \95 - 149 */
1711   6      , 137, /* \96 - 150 */
1712   6      , 139, /* \97 - 151 */
1713   7      ,  93, /* \98 - 152 */
1714  14      , 156, /* \99 - 153 */
1715  14      , 145, /* \9a - 154 */
1716   7      , 137, /* \9b - 155 */
1717  14 + 16 , 124, /* \9c - 156 */
1718   6      ,  59, /* \9d - 157 */
1719   6      ,  60, /* \9e - 158 */
1720  14      , 167, /* \9f - 159 */
1721   7      ,   4, /*   - 160 */
1722   7      ,  81, /* ¡ - 161 */
1723  10      ,   2, /* ¢ - 162 */
1724  10      ,   3, /* £ - 163 */
1725  10      ,   4, /* ¤ - 164 */
1726  10      ,   5, /* ¥ - 165 */
1727   7      ,  82, /* ¦ - 166 */
1728  10      ,   6, /* § - 167 */
1729   7      ,  83, /* ¨ - 168 */
1730  10      ,   7, /* © - 169 */
1731  14      ,   2, /* ª - 170 */
1732   8      ,  24, /* « - 171 */
1733  10      ,   8, /* ¬ - 172 */
1734   6      , 131, /*  - 173 */
1735  10      ,   9, /* ® - 174 */
1736   7      ,  84, /* ¯ - 175 */
1737  10      ,  10, /* ° - 176 */
1738   8      ,  23, /* ± - 177 */
1739  12      ,  51, /* ² - 178 */
1740  12      ,  70, /* ³ - 179 */
1741   7      ,  85, /* ´ - 180 */
1742  10      ,  11, /* µ - 181 */
1743  10      ,  12, /* ¶ - 182 */
1744  10      ,  13, /* · - 183 */
1745   7      ,  86, /* ¸ - 184 */
1746  12      ,  33, /* ¹ - 185 */
1747  14      , 124, /* º - 186 */
1748   8      ,  26, /* » - 187 */
1749  12      ,  21, /* ¼ - 188 */
1750  12      ,  25, /* ½ - 189 */
1751  12      ,  29, /* ¾ - 190 */
1752   7      ,  87, /* ¿ - 191 */
1753  14      ,   2, /* À - 192 */
1754  14      ,   2, /* Á - 193 */
1755  14      ,   2, /* Â - 194 */
1756  14      ,   2, /* Ã - 195 */
1757  14      ,   2, /* Ä - 196 */
1758  14      ,   2, /* Å - 197 */
1759  14 + 16 ,   2, /* Æ - 198 */
1760  14      ,  10, /* Ç - 199 */
1761  14      ,  33, /* È - 200 */
1762  14      ,  33, /* É - 201 */
1763  14      ,  33, /* Ê - 202 */
1764  14      ,  33, /* Ë - 203 */
1765  14      ,  50, /* Ì - 204 */
1766  14      ,  50, /* Í - 205 */
1767  14      ,  50, /* Î - 206 */
1768  14      ,  50, /* Ï - 207 */
1769  14      ,  26, /* Ð - 208 */
1770  14      , 112, /* Ñ - 209 */
1771  14      , 124, /* Ò - 210 */
1772  14      , 124, /* Ó - 211 */
1773  14      , 124, /* Ô - 212 */
1774  14      , 124, /* Õ - 213 */
1775  14      , 124, /* Ö - 214 */
1776   8      ,  28, /* × - 215 */
1777  14      , 124, /* Ø - 216 */
1778  14      , 159, /* Ù - 217 */
1779  14      , 159, /* Ú - 218 */
1780  14      , 159, /* Û - 219 */
1781  14      , 159, /* Ü - 220 */
1782  14      , 167, /* Ý - 221 */
1783  14 + 32 , 153, /* Þ - 222 */
1784  14 + 48 , 145, /* ß - 223 */
1785  14      ,   2, /* à - 224 */
1786  14      ,   2, /* á - 225 */
1787  14      ,   2, /* â - 226 */
1788  14      ,   2, /* ã - 227 */
1789  14      ,   2, /* ä - 228 */
1790  14      ,   2, /* å - 229 */
1791  14 + 16 ,   2, /* æ - 230 */
1792  14      ,  10, /* ç - 231 */
1793  14      ,  33, /* è - 232 */
1794  14      ,  33, /* é - 233 */
1795  14      ,  33, /* ê - 234 */
1796  14      ,  33, /* ë - 235 */
1797  14      ,  50, /* ì - 236 */
1798  14      ,  50, /* í - 237 */
1799  14      ,  50, /* î - 238 */
1800  14      ,  50, /* ï - 239 */
1801  14      ,  26, /* ð - 240 */
1802  14      , 112, /* ñ - 241 */
1803  14      , 124, /* ò - 242 */
1804  14      , 124, /* ó - 243 */
1805  14      , 124, /* ô - 244 */
1806  14      , 124, /* õ - 245 */
1807  14      , 124, /* ö - 246 */
1808   8      ,  29, /* ÷ - 247 */
1809  14      , 124, /* ø - 248 */
1810  14      , 159, /* ù - 249 */
1811  14      , 159, /* ú - 250 */
1812  14      , 159, /* û - 251 */
1813  14      , 159, /* ü - 252 */
1814  14      , 167, /* ý - 253 */
1815  14 + 32 , 153, /* þ - 254 */
1816  14      , 167  /* ÿ - 255 */ };
1817
1818 static const unsigned char LCM_Unicode_LUT_2[] = { 33, 44, 145 };
1819
1820 #define LCM_Diacritic_Start 131
1821
1822 static const unsigned char LCM_Diacritic_LUT[] = {
1823 123,  /* \83 - 131 */
1824   2,  /* \84 - 132 */
1825   2,  /* \85 - 133 */
1826   2,  /* \86 - 134 */
1827   2,  /* \87 - 135 */
1828   3,  /* \88 - 136 */
1829   2,  /* \89 - 137 */
1830  20,  /* \8a - 138 */
1831   2,  /* \8b - 139 */
1832   2,  /* \8c - 140 */
1833   2,  /* \8d - 141 */
1834   2,  /* \8e - 142 */
1835   2,  /* \8f - 143 */
1836   2,  /* \90 - 144 */
1837   2,  /* \91 - 145 */
1838   2,  /* \92 - 146 */
1839   2,  /* \93 - 147 */
1840   2,  /* \94 - 148 */
1841   2,  /* \95 - 149 */
1842   2,  /* \96 - 150 */
1843   2,  /* \97 - 151 */
1844   2,  /* \98 - 152 */
1845   2,  /* \99 - 153 */
1846  20,  /* \9a - 154 */
1847   2,  /* \9b - 155 */
1848   2,  /* \9c - 156 */
1849   2,  /* \9d - 157 */
1850   2,  /* \9e - 158 */
1851  19,  /* \9f - 159 */
1852   2,  /*   - 160 */
1853   2,  /* ¡ - 161 */
1854   2,  /* ¢ - 162 */
1855   2,  /* £ - 163 */
1856   2,  /* ¤ - 164 */
1857   2,  /* ¥ - 165 */
1858   2,  /* ¦ - 166 */
1859   2,  /* § - 167 */
1860   2,  /* ¨ - 168 */
1861   2,  /* © - 169 */
1862   3,  /* ª - 170 */
1863   2,  /* « - 171 */
1864   2,  /* ¬ - 172 */
1865   2,  /*  - 173 */
1866   2,  /* ® - 174 */
1867   2,  /* ¯ - 175 */
1868   2,  /* ° - 176 */
1869   2,  /* ± - 177 */
1870   2,  /* ² - 178 */
1871   2,  /* ³ - 179 */
1872   2,  /* ´ - 180 */
1873   2,  /* µ - 181 */
1874   2,  /* ¶ - 182 */
1875   2,  /* · - 183 */
1876   2,  /* ¸ - 184 */
1877   2,  /* ¹ - 185 */
1878   3,  /* º - 186 */
1879   2,  /* » - 187 */
1880   2,  /* ¼ - 188 */
1881   2,  /* ½ - 189 */
1882   2,  /* ¾ - 190 */
1883   2,  /* ¿ - 191 */
1884  15,  /* À - 192 */
1885  14,  /* Á - 193 */
1886  18,  /* Â - 194 */
1887  25,  /* Ã - 195 */
1888  19,  /* Ä - 196 */
1889  26,  /* Å - 197 */
1890   2,  /* Æ - 198 */
1891  28,  /* Ç - 199 */
1892  15,  /* È - 200 */
1893  14,  /* É - 201 */
1894  18,  /* Ê - 202 */
1895  19,  /* Ë - 203 */
1896  15,  /* Ì - 204 */
1897  14,  /* Í - 205 */
1898  18,  /* Î - 206 */
1899  19,  /* Ï - 207 */
1900 104,  /* Ð - 208 */
1901  25,  /* Ñ - 209 */
1902  15,  /* Ò - 210 */
1903  14,  /* Ó - 211 */
1904  18,  /* Ô - 212 */
1905  25,  /* Õ - 213 */
1906  19,  /* Ö - 214 */
1907   2,  /* × - 215 */
1908  33,  /* Ø - 216 */
1909  15,  /* Ù - 217 */
1910  14,  /* Ú - 218 */
1911  18,  /* Û - 219 */
1912  19,  /* Ü - 220 */
1913  14,  /* Ý - 221 */
1914   2,  /* Þ - 222 */
1915   2,  /* ß - 223 */
1916  15,  /* à - 224 */
1917  14,  /* á - 225 */
1918  18,  /* â - 226 */
1919  25,  /* ã - 227 */
1920  19,  /* ä - 228 */
1921  26,  /* å - 229 */
1922   2,  /* æ - 230 */
1923  28,  /* ç - 231 */
1924  15,  /* è - 232 */
1925  14,  /* é - 233 */
1926  18,  /* ê - 234 */
1927  19,  /* ë - 235 */
1928  15,  /* ì - 236 */
1929  14,  /* í - 237 */
1930  18,  /* î - 238 */
1931  19,  /* ï - 239 */
1932 104,  /* ð - 240 */
1933  25,  /* ñ - 241 */
1934  15,  /* ò - 242 */
1935  14,  /* ó - 243 */
1936  18,  /* ô - 244 */
1937  25,  /* õ - 245 */
1938  19,  /* ö - 246 */
1939   2,  /* ÷ - 247 */
1940  33,  /* ø - 248 */
1941  15,  /* ù - 249 */
1942  14,  /* ú - 250 */
1943  18,  /* û - 251 */
1944  19,  /* ü - 252 */
1945  14,  /* ý - 253 */
1946   2,  /* þ - 254 */
1947  19,  /* ÿ - 255 */
1948 } ;
1949
1950 /******************************************************************************
1951  * OLE2NLS_isPunctuation [INTERNAL]
1952  */
1953 static int OLE2NLS_isPunctuation(unsigned char c)
1954 {
1955   /* "punctuation character" in this context is a character which is
1956      considered "less important" during word sort comparison.
1957      See LCMapString implementation for the precise definition
1958      of "less important". */
1959
1960   return (LCM_Unicode_LUT[-2+2*c]==6);
1961 }
1962
1963 /******************************************************************************
1964  *              identity        [Internal]
1965  */
1966 static int identity(int c)
1967 {
1968   return c;
1969 }
1970
1971 /*************************************************************************
1972  *              LCMapString32A                [KERNEL32.492]
1973  *
1974  * Convert a string, or generate a sort key from it.
1975  *
1976  * If (mapflags & LCMAP_SORTKEY), the function will generate
1977  * a sort key for the source string.  Else, it will convert it
1978  * accordingly to the flags LCMAP_UPPERCASE, LCMAP_LOWERCASE,...
1979  *
1980  * RETURNS
1981  *    Error : 0.
1982  *    Success : length of the result string.
1983  *
1984  * NOTES
1985  *    If called with scrlen = -1, the function will compute the length
1986  *      of the 0-terminated string strsrc by itself.
1987  *
1988  *    If called with dstlen = 0, returns the buffer length that
1989  *      would be required.
1990  *
1991  *    NORM_IGNOREWIDTH means to compare ASCII and Unicode characters
1992  *    as if they are equal.  Since Wine separates ASCII and Unicode into
1993  *    separate functions, we shouldn't have to do anything for this flag.
1994  *    I added it to the list of flags that don't need a fixme message
1995  *    to make MS Word 95 not print several thousand fixme messages for
1996  *    this function.
1997  */
1998 INT32 WINAPI LCMapString32A(
1999         LCID lcid /* locale identifier created with MAKELCID;
2000                      LOCALE_SYSTEM_DEFAULT and LOCALE_USER_DEFAULT are
2001                      predefined values. */,
2002         DWORD mapflags /* flags */,
2003         LPCSTR srcstr  /* source buffer */,
2004         INT32 srclen   /* source length */,
2005         LPSTR dststr   /* destination buffer */,
2006         INT32 dstlen   /* destination buffer length */)
2007 {
2008   int i;
2009
2010   TRACE(string,"(0x%04lx,0x%08lx,%s,%d,%p,%d)\n",
2011         lcid,mapflags,srcstr,srclen,dststr,dstlen);
2012
2013   if ( ((dstlen!=0) && (dststr==NULL)) || (srcstr==NULL) )
2014   {
2015     ERR(ole, "(src=%s,dest=%s): Invalid NULL string\n", srcstr, dststr);
2016     SetLastError(ERROR_INVALID_PARAMETER);
2017     return 0;
2018   }
2019   if (srclen == -1)
2020     srclen = lstrlen32A(srcstr) + 1 ;    /* (include final '\0') */
2021
2022   if (mapflags & ~ ( LCMAP_UPPERCASE | LCMAP_LOWERCASE | LCMAP_SORTKEY |
2023                      NORM_IGNORECASE | NORM_IGNORENONSPACE | SORT_STRINGSORT |
2024                      NORM_IGNOREWIDTH) )
2025   {
2026     FIXME(string,"(0x%04lx,0x%08lx,%p,%d,%p,%d): "
2027           "unimplemented flags: 0x%08lx\n",
2028           lcid,mapflags,srcstr,srclen,dststr,dstlen,mapflags);
2029   }
2030
2031   if ( !(mapflags & LCMAP_SORTKEY) )
2032   {
2033     int (*f)(int)=identity;
2034
2035     if (dstlen==0)
2036       return srclen;  /* dstlen=0 means "do nothing but return required length" */
2037     if (dstlen<srclen)
2038       srclen=dstlen;  /* No, this case is not an error under Windows 95.
2039                          And no '\0' gets written. */
2040     if (mapflags & LCMAP_UPPERCASE)
2041       f = toupper;
2042     else if (mapflags & LCMAP_LOWERCASE)
2043       f = tolower;
2044     for (i=0; i < srclen; i++)
2045       dststr[i] = (CHAR) f(srcstr[i]);
2046     return srclen;
2047   }
2048
2049   /* else ... (mapflags & LCMAP_SORTKEY)  */
2050   {
2051     int unicode_len=0;
2052     int case_len=0;
2053     int diacritic_len=0;
2054     int delayed_punctuation_len=0;
2055     char *case_component;
2056     char *diacritic_component;
2057     char *delayed_punctuation_component;
2058     int room,count;
2059     int flag_stringsort = mapflags & SORT_STRINGSORT;
2060
2061     /* compute how much room we will need */
2062     for (i=0;i<srclen;i++)
2063     {
2064       int ofs;
2065       unsigned char source_char = srcstr[i];
2066       if (source_char!='\0')
2067       {
2068         if (flag_stringsort || !OLE2NLS_isPunctuation(source_char))
2069         {
2070           unicode_len++;
2071           if ( LCM_Unicode_LUT[-2+2*source_char] & ~15 )
2072             unicode_len++;             /* double letter */
2073         }
2074         else
2075         {
2076           delayed_punctuation_len++;
2077         }
2078       }
2079
2080       if (isupper(source_char))
2081         case_len=unicode_len;
2082
2083       ofs = source_char - LCM_Diacritic_Start;
2084       if ((ofs>=0) && (LCM_Diacritic_LUT[ofs]!=2))
2085         diacritic_len=unicode_len;
2086     }
2087
2088     if (mapflags & NORM_IGNORECASE)
2089       case_len=0;
2090     if (mapflags & NORM_IGNORENONSPACE)
2091       diacritic_len=0;
2092
2093     room =  2 * unicode_len              /* "unicode" component */
2094       +     diacritic_len                /* "diacritic" component */
2095       +     case_len                     /* "case" component */
2096       +     4 * delayed_punctuation_len  /* punctuation in word sort mode */
2097       +     4                            /* four '\1' separators */
2098       +     1  ;                         /* terminal '\0' */
2099     if (dstlen==0)
2100       return room;
2101     else if (dstlen<room)
2102     {
2103       SetLastError(ERROR_INSUFFICIENT_BUFFER);
2104       return 0;
2105     }
2106
2107     /*FIXME the Pointercheck should not be nessesary */
2108     if (IsBadWritePtr32 (dststr,room))
2109     { ERR (string,"bad destination buffer (dststr) : %p,%d\n",dststr,dstlen);
2110       SetLastError(ERROR_INSUFFICIENT_BUFFER);
2111       return 0;
2112     }
2113
2114     /* locate each component, write separators */
2115     diacritic_component = dststr + 2*unicode_len ;
2116     *diacritic_component++ = '\1';
2117     case_component = diacritic_component + diacritic_len ;
2118     *case_component++ = '\1';
2119     delayed_punctuation_component = case_component + case_len ;
2120     *delayed_punctuation_component++ = '\1';
2121     *delayed_punctuation_component++ = '\1';
2122
2123     /* read source string char by char, write
2124        corresponding weight in each component. */
2125     for (i=0,count=0;i<srclen;i++)
2126     {
2127       unsigned char source_char=srcstr[i];
2128       if (source_char!='\0')
2129       {
2130         int type,longcode;
2131         type = LCM_Unicode_LUT[-2+2*source_char];
2132         longcode = type >> 4;
2133         type &= 15;
2134         if (!flag_stringsort && OLE2NLS_isPunctuation(source_char))
2135         {
2136           UINT16 encrypted_location = (1<<15) + 7 + 4*count;
2137           *delayed_punctuation_component++ = (unsigned char) (encrypted_location>>8);
2138           *delayed_punctuation_component++ = (unsigned char) (encrypted_location&255);
2139                      /* big-endian is used here because it lets string comparison be
2140                         compatible with numerical comparison */
2141
2142           *delayed_punctuation_component++ = type;
2143           *delayed_punctuation_component++ = LCM_Unicode_LUT[-1+2*source_char];
2144                      /* assumption : a punctuation character is never a
2145                         double or accented letter */
2146         }
2147         else
2148         {
2149           dststr[2*count] = type;
2150           dststr[2*count+1] = LCM_Unicode_LUT[-1+2*source_char];
2151           if (longcode)
2152           {
2153             if (count<case_len)
2154               case_component[count] = ( isupper(source_char) ? 18 : 2 ) ;
2155             if (count<diacritic_len)
2156               diacritic_component[count] = 2; /* assumption: a double letter
2157                                                  is never accented */
2158             count++;
2159
2160             dststr[2*count] = type;
2161             dststr[2*count+1] = *(LCM_Unicode_LUT_2 - 1 + longcode);
2162             /* 16 in the first column of LCM_Unicode_LUT  -->  longcode = 1
2163                32 in the first column of LCM_Unicode_LUT  -->  longcode = 2
2164                48 in the first column of LCM_Unicode_LUT  -->  longcode = 3 */
2165           }
2166
2167           if (count<case_len)
2168             case_component[count] = ( isupper(source_char) ? 18 : 2 ) ;
2169           if (count<diacritic_len)
2170           {
2171             int ofs = source_char - LCM_Diacritic_Start;
2172             diacritic_component[count] = (ofs>=0 ? LCM_Diacritic_LUT[ofs] : 2);
2173           }
2174           count++;
2175         }
2176       }
2177     }
2178     dststr[room-1] = '\0';
2179     return room;
2180   }
2181 }
2182
2183 /*************************************************************************
2184  *              LCMapString32W                [KERNEL32.493]
2185  *
2186  * Convert a string, or generate a sort key from it.
2187  *
2188  * NOTE
2189  *
2190  * See LCMapString32A for documentation
2191  */
2192 INT32 WINAPI LCMapString32W(
2193         LCID lcid,DWORD mapflags,LPCWSTR srcstr,INT32 srclen,LPWSTR dststr,
2194         INT32 dstlen)
2195 {
2196   int i;
2197
2198   TRACE(string,"(0x%04lx,0x%08lx,%p,%d,%p,%d)\n",
2199         lcid,mapflags,srcstr,srclen,dststr,dstlen);
2200
2201   if ( ((dstlen!=0) && (dststr==NULL)) || (srcstr==NULL) )
2202   {
2203     ERR(ole, "(src=%p,dst=%p): Invalid NULL string\n", srcstr, dststr);
2204     SetLastError(ERROR_INVALID_PARAMETER);
2205     return 0;
2206   }
2207   if (srclen==-1)
2208     srclen = lstrlen32W(srcstr)+1;
2209   if (mapflags & LCMAP_SORTKEY)
2210   {
2211     FIXME(string,"(0x%04lx,0x%08lx,%p,%d,%p,%d): "
2212           "unimplemented flags: 0x%08lx\n",
2213           lcid,mapflags,srcstr,srclen,dststr,dstlen,mapflags);
2214     return 0;
2215   }
2216   else
2217   {
2218     int (*f)(int)=identity;
2219
2220     if (dstlen==0)
2221       return srclen;
2222     if (dstlen<srclen)
2223       return 0;
2224     if (mapflags & LCMAP_UPPERCASE)
2225       f = toupper;
2226     else if (mapflags & LCMAP_LOWERCASE)
2227       f = tolower;
2228     for (i=0; i < srclen; i++)
2229       dststr[i] = (WCHAR) f(srcstr[i]);
2230     return srclen;
2231   }
2232 }
2233
2234 /***********************************************************************
2235  *           CompareString16       (OLE2NLS.8)
2236  */
2237 UINT16 WINAPI CompareString16(DWORD lcid,DWORD fdwStyle,
2238                               LPCSTR s1,DWORD l1,LPCSTR s2,DWORD l2)
2239 {
2240         return (UINT16)CompareString32A(lcid,fdwStyle,s1,l1,s2,l2);
2241 }
2242
2243 /******************************************************************************
2244  *              CompareString32A        [KERNEL32.143]
2245  * Compares two strings using locale
2246  *
2247  * RETURNS
2248  *
2249  * success: CSTR_LESS_THAN, CSTR_EQUAL, CSTR_GREATER_THAN
2250  * failure: 0
2251  *
2252  * NOTES
2253  *
2254  * Defaults to a word sort, but uses a string sort if
2255  * SORT_STRINGSORT is set.
2256  * Calls SetLastError for ERROR_INVALID_FLAGS, ERROR_INVALID_PARAMETER.
2257  *
2258  * BUGS
2259  *
2260  * This implementation ignores the locale
2261  *
2262  * FIXME
2263  *
2264  * Quite inefficient.
2265  */
2266 UINT32 WINAPI CompareString32A(
2267     DWORD lcid,     /* locale ID */
2268     DWORD fdwStyle, /* comparison-style options */
2269     LPCSTR s1,      /* first string */
2270     DWORD l1,       /* length of first string */
2271     LPCSTR s2,      /* second string */
2272     DWORD l2)       /* length of second string */
2273 {
2274   int mapstring_flags;
2275   int len1,len2;
2276   int result;
2277   LPSTR sk1,sk2;
2278   TRACE(ole,"%s and %s\n",
2279         debugstr_a (s1), debugstr_a (s2));
2280
2281   if ( (s1==NULL) || (s2==NULL) )
2282   {
2283     ERR(ole, "(s1=%s,s2=%s): Invalid NULL string\n", s1, s2);
2284     SetLastError(ERROR_INVALID_PARAMETER);
2285     return 0;
2286   }
2287
2288   if(fdwStyle & NORM_IGNORESYMBOLS)
2289     FIXME(ole, "IGNORESYMBOLS not supported\n");
2290
2291   mapstring_flags = LCMAP_SORTKEY | fdwStyle ;
2292   len1 = LCMapString32A(lcid,mapstring_flags,s1,l1,NULL,0);
2293   len2 = LCMapString32A(lcid,mapstring_flags,s2,l2,NULL,0);
2294
2295   if ((len1==0)||(len2==0))
2296     return 0;     /* something wrong happened */
2297
2298   sk1 = (LPSTR)HeapAlloc(GetProcessHeap(),0,len1);
2299   sk2 = (LPSTR)HeapAlloc(GetProcessHeap(),0,len2);
2300   if ( (!LCMapString32A(lcid,mapstring_flags,s1,l1,sk1,len1))
2301          || (!LCMapString32A(lcid,mapstring_flags,s2,l2,sk2,len2)) )
2302   {
2303     ERR(ole,"Bug in LCmapString32A.\n");
2304     result = 0;
2305   }
2306   else
2307   {
2308     /* strcmp doesn't necessarily return -1, 0, or 1 */
2309     result = strcmp(sk1,sk2);
2310   }
2311   HeapFree(GetProcessHeap(),0,sk1);
2312   HeapFree(GetProcessHeap(),0,sk2);
2313
2314   if (result < 0)
2315     return 1;
2316   if (result == 0)
2317     return 2;
2318
2319   /* must be greater, if we reach this point */
2320   return 3;
2321 }
2322
2323 /******************************************************************************
2324  *              CompareString32W        [KERNEL32.144]
2325  * This implementation ignores the locale
2326  * FIXME :  Does only string sort.  Should
2327  * be reimplemented the same way as CompareString32A.
2328  */
2329 UINT32 WINAPI CompareString32W(DWORD lcid, DWORD fdwStyle,
2330                                LPCWSTR s1, DWORD l1, LPCWSTR s2,DWORD l2)
2331 {
2332         int len,ret;
2333         if(fdwStyle & NORM_IGNORENONSPACE)
2334                 FIXME(ole,"IGNORENONSPACE not supprted\n");
2335         if(fdwStyle & NORM_IGNORESYMBOLS)
2336                 FIXME(ole,"IGNORESYMBOLS not supported\n");
2337
2338         /* Is strcmp defaulting to string sort or to word sort?? */
2339         /* FIXME: Handle NORM_STRINGSORT */
2340         l1 = (l1==-1)?lstrlen32W(s1):l1;
2341         l2 = (l2==-1)?lstrlen32W(s2):l2;
2342         len = l1<l2 ? l1:l2;
2343         ret = (fdwStyle & NORM_IGNORECASE) ?
2344                 lstrncmpi32W(s1,s2,len) : lstrncmp32W(s1,s2,len);
2345         /* not equal, return 1 or 3 */
2346         if(ret!=0) return ret+2;
2347         /* same len, return 2 */
2348         if(l1==l2) return 2;
2349         /* the longer one is lexically greater */
2350         return (l1<l2)? 1 : 3;
2351 }
2352
2353 /******************************************************************************
2354  *              OLE_GetFormatA  [Internal]
2355  *
2356  * FIXME
2357  *    Why is it WINAPI if internal?
2358  *
2359  This function implements stuff for GetDateFormat() and
2360  GetTimeFormat().
2361
2362   d    single-digit (no leading zero) day (of month)
2363   dd   two-digit day (of month)
2364   ddd  short day-of-week name
2365   dddd long day-of-week name
2366   M    single-digit month
2367   MM   two-digit month
2368   MMM  short month name
2369   MMMM full month name
2370   y    two-digit year, no leading 0
2371   yy   two-digit year
2372   yyyy four-digit year
2373   gg   era string
2374   h    hours with no leading zero (12-hour)
2375   hh   hours with full two digits
2376   H    hours with no leading zero (24-hour)
2377   HH   hours with full two digits
2378   m    minutes with no leading zero
2379   mm   minutes with full two digits
2380   s    seconds with no leading zero
2381   ss   seconds with full two digits
2382   t    time marker (A or P)
2383   tt   time marker (AM, PM)
2384   ''   used to quote literal characters
2385   ''   (within a quoted string) indicates a literal '
2386
2387  These functions REQUIRE valid locale, date,  and format.
2388  */
2389 INT32 WINAPI OLE_GetFormatA(LCID locale,
2390                             DWORD flags,
2391                             DWORD tflags,
2392                             LPSYSTEMTIME xtime,
2393                             LPCSTR _format,     /*in*/
2394                             LPSTR date,         /*out*/
2395                             INT32 datelen)
2396 {
2397    INT32 inpos, outpos;
2398    int count, type, inquote, Overflow;
2399    char buf[40];
2400    char format[40];
2401    char * pos;
2402    int buflen;
2403
2404    const char * _dgfmt[] = { "%d", "%02d" };
2405    const char ** dgfmt = _dgfmt - 1;
2406
2407    /* report, for debugging */
2408    TRACE(ole, "(0x%lx,0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt=%p \'%s\' , %p, len=%d)\n",
2409          locale, flags, tflags,
2410          xtime->wDay, xtime->wHour, xtime->wMinute, xtime->wSecond,
2411          _format, _format, date, datelen);
2412
2413    /* initalize state variables and output buffer */
2414    inpos = outpos = 0;
2415    count = 0; inquote = 0; Overflow = 0;
2416    type = '\0';
2417    date[0] = buf[0] = '\0';
2418
2419    strcpy(format,_format);
2420
2421    /* alter the formatstring, while it works for all languages now in wine
2422    its possible that it fails when the time looks like ss:mm:hh as example*/
2423    if (tflags & (TIME_NOMINUTESORSECONDS))
2424    { if ((pos = strstr ( format, ":mm")))
2425      { memcpy ( pos, pos+3, strlen(format)-(pos-format)-2 );
2426      }
2427    }
2428    if (tflags & (TIME_NOSECONDS))
2429    { if ((pos = strstr ( format, ":ss")))
2430      { memcpy ( pos, pos+3, strlen(format)-(pos-format)-2 );
2431      }
2432    }
2433
2434    for (inpos = 0;; inpos++) {
2435       /* 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]); */
2436       if (inquote) {
2437          if (format[inpos] == '\'') {
2438             if (format[inpos+1] == '\'') {
2439                inpos += 1;
2440                date[outpos++] = '\'';
2441             } else {
2442                inquote = 0;
2443                continue; /* we did nothing to the output */
2444             }
2445          } else if (format[inpos] == '\0') {
2446             date[outpos++] = '\0';
2447             if (outpos > datelen) Overflow = 1;
2448             break;
2449          } else {
2450             date[outpos++] = format[inpos];
2451             if (outpos > datelen) {
2452                Overflow = 1;
2453                date[outpos-1] = '\0'; /* this is the last place where
2454                                          it's safe to write */
2455                break;
2456             }
2457          }
2458       } else if (  (count && (format[inpos] != type))
2459                    || count == 4
2460                    || (count == 2 && strchr("ghHmst", type)) )
2461        {
2462             if         (type == 'd') {
2463                if        (count == 4) {
2464                   GetLocaleInfo32A(locale,
2465                                    LOCALE_SDAYNAME1
2466                                    + xtime->wDayOfWeek - 1,
2467                                    buf, sizeof(buf));
2468                } else if (count == 3) {
2469                            GetLocaleInfo32A(locale,
2470                                             LOCALE_SABBREVDAYNAME1
2471                                             + xtime->wDayOfWeek - 1,
2472                                             buf, sizeof(buf));
2473                       } else {
2474                   sprintf(buf, dgfmt[count], xtime->wDay);
2475                }
2476             } else if (type == 'M') {
2477                if (count == 3) {
2478                   GetLocaleInfo32A(locale,
2479                                    LOCALE_SABBREVMONTHNAME1
2480                                    + xtime->wMonth - 1,
2481                                    buf, sizeof(buf));
2482                } else if (count == 4) {
2483                   GetLocaleInfo32A(locale,
2484                                    LOCALE_SMONTHNAME1
2485                                    + xtime->wMonth - 1,
2486                                    buf, sizeof(buf));
2487                  } else {
2488                   sprintf(buf, dgfmt[count], xtime->wMonth);
2489                }
2490             } else if (type == 'y') {
2491                if (count == 4) {
2492                       sprintf(buf, "%d", xtime->wYear);
2493                } else if (count == 3) {
2494                   strcpy(buf, "yyy");
2495                   WARN(ole, "unknown format, c=%c, n=%d\n",  type, count);
2496                  } else {
2497                   sprintf(buf, dgfmt[count], xtime->wYear % 100);
2498                }
2499             } else if (type == 'g') {
2500                if        (count == 2) {
2501                   FIXME(ole, "LOCALE_ICALENDARTYPE unimp.\n");
2502                   strcpy(buf, "AD");
2503             } else {
2504                   strcpy(buf, "g");
2505                   WARN(ole, "unknown format, c=%c, n=%d\n", type, count);
2506                }
2507             } else if (type == 'h') {
2508                /* gives us hours 1:00 -- 12:00 */
2509                sprintf(buf, dgfmt[count], (xtime->wHour-1)%12 +1);
2510             } else if (type == 'H') {
2511                /* 24-hour time */
2512                sprintf(buf, dgfmt[count], xtime->wHour);
2513             } else if ( type == 'm') {
2514                sprintf(buf, dgfmt[count], xtime->wMinute);
2515             } else if ( type == 's') {
2516                sprintf(buf, dgfmt[count], xtime->wSecond);
2517             } else if (type == 't') {
2518                if        (count == 1) {
2519                   sprintf(buf, "%c", (xtime->wHour < 12) ? 'A' : 'P');
2520                } else if (count == 2) {
2521                   /* sprintf(buf, "%s", (xtime->wHour < 12) ? "AM" : "PM"); */
2522                   GetLocaleInfo32A(locale,
2523                                    (xtime->wHour<12)
2524                                    ? LOCALE_S1159 : LOCALE_S2359,
2525                                    buf, sizeof(buf));
2526                }
2527             };
2528
2529             /* we need to check the next char in the format string
2530                again, no matter what happened */
2531             inpos--;
2532
2533             /* add the contents of buf to the output */
2534             buflen = strlen(buf);
2535             if (outpos + buflen < datelen) {
2536                date[outpos] = '\0'; /* for strcat to hook onto */
2537                  strcat(date, buf);
2538                outpos += buflen;
2539             } else {
2540                date[outpos] = '\0';
2541                strncat(date, buf, datelen - outpos);
2542                  date[datelen - 1] = '\0';
2543                  SetLastError(ERROR_INSUFFICIENT_BUFFER);
2544                WARN(ole, "insufficient buffer\n");
2545                  return 0;
2546             }
2547
2548             /* reset the variables we used to keep track of this item */
2549             count = 0;
2550             type = '\0';
2551          } else if (format[inpos] == '\0') {
2552             /* we can't check for this at the loop-head, because
2553                that breaks the printing of the last format-item */
2554             date[outpos] = '\0';
2555             break;
2556          } else if (count) {
2557             /* continuing a code for an item */
2558             count +=1;
2559             continue;
2560          } else if (strchr("hHmstyMdg", format[inpos])) {
2561             type = format[inpos];
2562             count = 1;
2563             continue;
2564          } else if (format[inpos] == '\'') {
2565             inquote = 1;
2566             continue;
2567        } else {
2568             date[outpos++] = format[inpos];
2569          }
2570       /* now deal with a possible buffer overflow */
2571       if (outpos >= datelen) {
2572        date[datelen - 1] = '\0';
2573        SetLastError(ERROR_INSUFFICIENT_BUFFER);
2574        return 0;
2575       }
2576    }
2577
2578    if (Overflow) {
2579       SetLastError(ERROR_INSUFFICIENT_BUFFER);
2580    };
2581
2582    /* finish it off with a string terminator */
2583    outpos++;
2584    /* sanity check */
2585    if (outpos > datelen-1) outpos = datelen-1;
2586    date[outpos] = '\0';
2587
2588    TRACE(ole, "OLE_GetFormatA returns string '%s', len %d\n",
2589                date, outpos);
2590    return outpos;
2591 }
2592
2593 /******************************************************************************
2594  * OLE_GetFormatW [INTERNAL]
2595  */
2596 INT32 WINAPI OLE_GetFormatW(LCID locale, DWORD flags, DWORD tflags,
2597                             LPSYSTEMTIME xtime,
2598                             LPCWSTR format,
2599                             LPWSTR output, INT32 outlen)
2600 {
2601    INT32   inpos, outpos;
2602    int     count, type=0, inquote;
2603    int     Overflow; /* loop check */
2604    WCHAR   buf[40];
2605    int     buflen=0;
2606    WCHAR   arg0[] = {0}, arg1[] = {'%','d',0};
2607    WCHAR   arg2[] = {'%','0','2','d',0};
2608    WCHAR  *argarr[] = {arg0, arg1, arg2};
2609    int     datevars=0, timevars=0;
2610
2611    /* make a debug report */
2612    TRACE(ole, "args: 0x%lx, 0x%lx, 0x%lx, time(d=%d,h=%d,m=%d,s=%d), fmt:%s (at %p),
2613          %p with max len %d\n",
2614          locale, flags, tflags,
2615          xtime->wDay, xtime->wHour, xtime->wMinute, xtime->wSecond,
2616          debugstr_w(format), format, output, outlen);
2617
2618
2619    /* initialize state variables */
2620    inpos = outpos = 0;
2621    count = 0;
2622    inquote = Overflow = 0;
2623    /* this is really just a sanity check */
2624    output[0] = buf[0] = 0;
2625
2626    /* this loop is the core of the function */
2627    for (inpos = 0; /* we have several break points */ ; inpos++) {
2628       if (inquote) {
2629          if (format[inpos] == (WCHAR) '\'') {
2630             if (format[inpos+1] == '\'') {
2631                inpos++;
2632                output[outpos++] = '\'';
2633             } else {
2634                inquote = 0;
2635                continue;
2636             }
2637          } else if (format[inpos] == 0) {
2638             output[outpos++] = 0;
2639             if (outpos > outlen) Overflow = 1;
2640             break;  /*  normal exit (within a quote) */
2641          } else {
2642             output[outpos++] = format[inpos]; /* copy input */
2643             if (outpos > outlen) {
2644                Overflow = 1;
2645                output[outpos-1] = 0;
2646                break;
2647             }
2648          }
2649       } else if (  (count && (format[inpos] != type))
2650                    || ( (count==4 && type =='y') ||
2651                         (count==4 && type =='M') ||
2652                         (count==4 && type =='d') ||
2653                         (count==2 && type =='g') ||
2654                         (count==2 && type =='h') ||
2655                         (count==2 && type =='H') ||
2656                         (count==2 && type =='m') ||
2657                         (count==2 && type =='s') ||
2658                         (count==2 && type =='t') )  ) {
2659          if        (type == 'd') {
2660             if        (count == 3) {
2661                GetLocaleInfo32W(locale,
2662                              LOCALE_SDAYNAME1 + xtime->wDayOfWeek -1,
2663                              buf, sizeof(buf)/sizeof(WCHAR) );
2664             } else if (count == 3) {
2665                GetLocaleInfo32W(locale,
2666                                 LOCALE_SABBREVDAYNAME1 +
2667                                 xtime->wDayOfWeek -1,
2668                                 buf, sizeof(buf)/sizeof(WCHAR) );
2669             } else {
2670                wsnprintf32W(buf, 5, argarr[count], xtime->wDay );
2671             };
2672          } else if (type == 'M') {
2673             if        (count == 4) {
2674                GetLocaleInfo32W(locale,  LOCALE_SMONTHNAME1 +
2675                                 xtime->wMonth -1, buf,
2676                                 sizeof(buf)/sizeof(WCHAR) );
2677             } else if (count == 3) {
2678                GetLocaleInfo32W(locale,  LOCALE_SABBREVMONTHNAME1 +
2679                                 xtime->wMonth -1, buf,
2680                                 sizeof(buf)/sizeof(WCHAR) );
2681             } else {
2682                wsnprintf32W(buf, 5, argarr[count], xtime->wMonth);
2683             }
2684          } else if (type == 'y') {
2685             if        (count == 4) {
2686                wsnprintf32W(buf, 6, argarr[1] /* "%d" */,
2687                          xtime->wYear);
2688             } else if (count == 3) {
2689                lstrcpynAtoW(buf, "yyy", 5);
2690             } else {
2691                wsnprintf32W(buf, 6, argarr[count],
2692                             xtime->wYear % 100);
2693             }
2694          } else if (type == 'g') {
2695             if        (count == 2) {
2696                FIXME(ole, "LOCALE_ICALENDARTYPE unimplemented\n");
2697                lstrcpynAtoW(buf, "AD", 5);
2698             } else {
2699                /* Win API sez we copy it verbatim */
2700                lstrcpynAtoW(buf, "g", 5);
2701             }
2702          } else if (type == 'h') {
2703             /* hours 1:00-12:00 --- is this right? */
2704             wsnprintf32W(buf, 5, argarr[count],
2705                          (xtime->wHour-1)%12 +1);
2706          } else if (type == 'H') {
2707             wsnprintf32W(buf, 5, argarr[count],
2708                          xtime->wHour);
2709          } else if (type == 'm' ) {
2710             wsnprintf32W(buf, 5, argarr[count],
2711                          xtime->wMinute);
2712          } else if (type == 's' ) {
2713             wsnprintf32W(buf, 5, argarr[count],
2714                          xtime->wSecond);
2715          } else if (type == 't') {
2716             GetLocaleInfo32W(locale, (xtime->wHour < 12) ?
2717                              LOCALE_S1159 : LOCALE_S2359,
2718                              buf, sizeof(buf) );
2719             if        (count == 1) {
2720                buf[1] = 0;
2721             }
2722 }
2723
2724          /* no matter what happened,  we need to check this next
2725             character the next time we loop through */
2726          inpos--;
2727
2728          /* cat buf onto the output */
2729          outlen = lstrlen32W(buf);
2730          if (outpos + buflen < outlen) {
2731             output[outpos] = 0;  /* a "hook" for strcat */
2732             lstrcat32W(output, buf);
2733             outpos += buflen;
2734          } else {
2735             output[outpos] = 0;
2736             lstrcatn32W(output, buf, outlen - outpos);
2737             output[outlen - 1] = 0;
2738             Overflow = 1;
2739             break; /* Abnormal exit */
2740          }
2741
2742          /* reset the variables we used this time */
2743          count = 0;
2744          type = '\0';
2745       } else if (format[inpos] == 0) {
2746          /* we can't check for this at the beginning,  because that
2747          would keep us from printing a format spec that ended the
2748          string */
2749          output[outpos] = 0;
2750          break;  /*  NORMAL EXIT  */
2751       } else if (count) {
2752          /* how we keep track of the middle of a format spec */
2753          count++;
2754          continue;
2755       } else if ( (datevars && (format[inpos]=='d' ||
2756                                 format[inpos]=='M' ||
2757                                 format[inpos]=='y' ||
2758                                 format[inpos]=='g')  ) ||
2759                   (timevars && (format[inpos]=='H' ||
2760                                 format[inpos]=='h' ||
2761                                 format[inpos]=='m' ||
2762                                 format[inpos]=='s' ||
2763                                 format[inpos]=='t') )    ) {
2764          type = format[inpos];
2765          count = 1;
2766          continue;
2767       } else if (format[inpos] == '\'') {
2768          inquote = 1;
2769          continue;
2770       } else {
2771          /* unquoted literals */
2772          output[outpos++] = format[inpos];
2773       }
2774    }
2775
2776    if (Overflow) {
2777       SetLastError(ERROR_INSUFFICIENT_BUFFER);
2778       WARN(ole, " buffer overflow\n");
2779    };
2780
2781    /* final string terminator and sanity check */
2782    outpos++;
2783    if (outpos > outlen-1) outpos = outlen-1;
2784    output[outpos] = '0';
2785
2786    TRACE(ole, " returning %s\n", debugstr_w(output));
2787
2788    return (!Overflow) ? outlen : 0;
2789
2790 }
2791
2792
2793 /******************************************************************************
2794  *              GetDateFormat32A        [KERNEL32.310]
2795  * Makes an ASCII string of the date
2796  *
2797  * This function uses format to format the date,  or,  if format
2798  * is NULL, uses the default for the locale.  format is a string
2799  * of literal fields and characters as follows:
2800  *
2801  * - d    single-digit (no leading zero) day (of month)
2802  * - dd   two-digit day (of month)
2803  * - ddd  short day-of-week name
2804  * - dddd long day-of-week name
2805  * - M    single-digit month
2806  * - MM   two-digit month
2807  * - MMM  short month name
2808  * - MMMM full month name
2809  * - y    two-digit year, no leading 0
2810  * - yy   two-digit year
2811  * - yyyy four-digit year
2812  * - gg   era string
2813  *
2814  */
2815 INT32 WINAPI GetDateFormat32A(LCID locale,DWORD flags,
2816                               LPSYSTEMTIME xtime,
2817                               LPCSTR format, LPSTR date,INT32 datelen)
2818 {
2819
2820   char format_buf[40];
2821   LPCSTR thisformat;
2822   SYSTEMTIME t;
2823   LPSYSTEMTIME thistime;
2824   LCID thislocale;
2825   INT32 ret;
2826
2827   TRACE(ole,"(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",
2828               locale,flags,xtime,format,date,datelen);
2829
2830   if (!locale) {
2831      locale = LOCALE_SYSTEM_DEFAULT;
2832      };
2833
2834   if (locale == LOCALE_SYSTEM_DEFAULT) {
2835      thislocale = GetSystemDefaultLCID();
2836   } else if (locale == LOCALE_USER_DEFAULT) {
2837      thislocale = GetUserDefaultLCID();
2838   } else {
2839      thislocale = locale;
2840    };
2841
2842   if (xtime == NULL) {
2843      GetSystemTime(&t);
2844      thistime = &t;
2845   } else {
2846      thistime = xtime;
2847   };
2848
2849   if (format == NULL) {
2850      GetLocaleInfo32A(thislocale, ((flags&DATE_LONGDATE)
2851                                    ? LOCALE_SLONGDATE
2852                                    : LOCALE_SSHORTDATE),
2853                       format_buf, sizeof(format_buf));
2854      thisformat = format_buf;
2855   } else {
2856      thisformat = format;
2857   };
2858
2859
2860   ret = OLE_GetFormatA(thislocale, flags, 0, thistime, thisformat,
2861                        date, datelen);
2862
2863
2864    TRACE(ole,
2865                "GetDateFormat32A() returning %d, with data=%s\n",
2866                ret, date);
2867   return ret;
2868 }
2869
2870 /******************************************************************************
2871  *              GetDateFormat32W        [KERNEL32.311]
2872  * Makes a Unicode string of the date
2873  *
2874  * Acts the same as GetDateFormat32A(),  except that it's Unicode.
2875  * Accepts & returns sizes as counts of Unicode characters.
2876  *
2877  */
2878 INT32 WINAPI GetDateFormat32W(LCID locale,DWORD flags,
2879                               LPSYSTEMTIME xtime,
2880                               LPCWSTR format,
2881                               LPWSTR date, INT32 datelen)
2882 {
2883    short datearr[] = {'1','9','9','4','-','1','-','1',0};
2884
2885    FIXME(ole, "STUB (should call OLE_GetFormatW)\n");
2886    lstrcpyn32W(date, datearr, datelen);
2887    return (  datelen < 9) ? datelen : 9;
2888
2889
2890 }
2891
2892 /**************************************************************************
2893  *              EnumDateFormats32A      (KERNEL32.198)
2894  */
2895 BOOL32 WINAPI EnumDateFormats32A(
2896   DATEFMT_ENUMPROC32A lpDateFmtEnumProc, LCID Locale,  DWORD dwFlags)
2897 {
2898   FIXME(ole, "Only US English supported\n");
2899
2900   if(!lpDateFmtEnumProc)
2901     {
2902       SetLastError(ERROR_INVALID_PARAMETER);
2903       return FALSE;
2904     }
2905
2906   switch(dwFlags)
2907     {
2908       case DATE_SHORTDATE:
2909         if(!(*lpDateFmtEnumProc)("M/d/yy")) return TRUE;
2910         if(!(*lpDateFmtEnumProc)("M/d/yyyy")) return TRUE;
2911         if(!(*lpDateFmtEnumProc)("MM/dd/yy")) return TRUE;
2912         if(!(*lpDateFmtEnumProc)("MM/dd/yyyy")) return TRUE;
2913         if(!(*lpDateFmtEnumProc)("yy/MM/dd")) return TRUE;
2914         if(!(*lpDateFmtEnumProc)("dd-MMM-yy")) return TRUE;
2915         return TRUE;
2916       case DATE_LONGDATE:
2917         if(!(*lpDateFmtEnumProc)("dddd, MMMM dd, yyyy")) return TRUE;
2918         if(!(*lpDateFmtEnumProc)("MMMM dd, yyyy")) return TRUE;
2919         if(!(*lpDateFmtEnumProc)("dddd, dd MMMM, yyyy")) return TRUE;
2920         if(!(*lpDateFmtEnumProc)("dd MMMM, yyyy")) return TRUE;
2921         return TRUE;
2922       default:
2923         FIXME(ole, "Unknown date format (%ld)\n", dwFlags);
2924         SetLastError(ERROR_INVALID_PARAMETER);
2925         return FALSE;
2926     }
2927 }
2928
2929 /**************************************************************************
2930  *              EnumDateFormats32W      (KERNEL32.199)
2931  */
2932 BOOL32 WINAPI EnumDateFormats32W(
2933   DATEFMT_ENUMPROC32W lpDateFmtEnumProc, LCID Locale, DWORD dwFlags)
2934 {
2935   FIXME(ole, "(%p, %ld, %ld): stub\n", lpDateFmtEnumProc, Locale, dwFlags);
2936   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2937   return FALSE;
2938 }
2939
2940 /**************************************************************************
2941  *              EnumTimeFormats32A      (KERNEL32.210)
2942  */
2943 BOOL32 WINAPI EnumTimeFormats32A(
2944   TIMEFMT_ENUMPROC32A lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags)
2945 {
2946   FIXME(ole, "Only US English supported\n");
2947
2948   if(!lpTimeFmtEnumProc)
2949     {
2950       SetLastError(ERROR_INVALID_PARAMETER);
2951       return FALSE;
2952     }
2953
2954   if(dwFlags)
2955     {
2956       FIXME(ole, "Unknown time format (%ld)\n", dwFlags);
2957     }
2958
2959   if(!(*lpTimeFmtEnumProc)("h:mm:ss tt")) return TRUE;
2960   if(!(*lpTimeFmtEnumProc)("hh:mm:ss tt")) return TRUE;
2961   if(!(*lpTimeFmtEnumProc)("H:mm:ss")) return TRUE;
2962   if(!(*lpTimeFmtEnumProc)("HH:mm:ss")) return TRUE;
2963
2964   return TRUE;
2965 }
2966
2967 /**************************************************************************
2968  *              EnumTimeFormats32W      (KERNEL32.211)
2969  */
2970 BOOL32 WINAPI EnumTimeFormats32W(
2971   TIMEFMT_ENUMPROC32W lpTimeFmtEnumProc, LCID Locale, DWORD dwFlags)
2972 {
2973   FIXME(ole, "(%p,%ld,%ld): stub", lpTimeFmtEnumProc, Locale, dwFlags);
2974   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2975   return FALSE;
2976 }
2977
2978 /**************************************************************************
2979  *              GetNumberFormat32A      (KERNEL32.355)
2980  */
2981 INT32 WINAPI GetNumberFormat32A(LCID locale, DWORD dwflags,
2982                                LPCSTR lpvalue,   const NUMBERFMT32A * lpFormat,
2983                                LPSTR lpNumberStr, int cchNumber)
2984 {
2985  int n;
2986
2987  FIXME(file,"%s: stub, no reformating done\n",lpvalue);
2988
2989  n = strlen(lpvalue);
2990  if (cchNumber) {
2991    strncpy(lpNumberStr,lpvalue,cchNumber);
2992    if (cchNumber <= n) {
2993      lpNumberStr[cchNumber-1] = 0;
2994      n = cchNumber-1;
2995    }
2996  }
2997  return n;
2998 }
2999 /**************************************************************************
3000  *              GetNumberFormat32W      (KERNEL32.xxx)
3001  */
3002 INT32 WINAPI GetNumberFormat32W(LCID locale, DWORD dwflags,
3003                                LPCWSTR lpvalue,  const NUMBERFMT32W * lpFormat,
3004                                LPWSTR lpNumberStr, int cchNumber)
3005 {
3006  int n;
3007
3008  FIXME(file,"%s: stub, no reformating done\n",debugstr_w(lpvalue));
3009
3010  n = lstrlen32W(lpvalue);
3011  if (cchNumber) {
3012    lstrcpyn32W(lpNumberStr,lpvalue,cchNumber);
3013    if (cchNumber <= n) {
3014      lpNumberStr[cchNumber-1] = 0;
3015      n = cchNumber-1;
3016    }
3017  }
3018  return n;
3019 }
3020 /******************************************************************************
3021  *              OLE2NLS_CheckLocale     [intern]
3022  */
3023 static LCID OLE2NLS_CheckLocale (LCID locale)
3024 {
3025         if (!locale)
3026         { locale = LOCALE_SYSTEM_DEFAULT;
3027         }
3028
3029         if (locale == LOCALE_SYSTEM_DEFAULT)
3030         { return GetSystemDefaultLCID();
3031         }
3032         else if (locale == LOCALE_USER_DEFAULT)
3033         { return GetUserDefaultLCID();
3034         }
3035         else
3036         { return locale;
3037         }
3038 }
3039 /******************************************************************************
3040  *              GetTimeFormat32A        [KERNEL32.422]
3041  * Makes an ASCII string of the time
3042  *
3043  * Formats date according to format,  or locale default if format is
3044  * NULL. The format consists of literal characters and fields as follows:
3045  *
3046  * h  hours with no leading zero (12-hour)
3047  * hh hours with full two digits
3048  * H  hours with no leading zero (24-hour)
3049  * HH hours with full two digits
3050  * m  minutes with no leading zero
3051  * mm minutes with full two digits
3052  * s  seconds with no leading zero
3053  * ss seconds with full two digits
3054  * t  time marker (A or P)
3055  * tt time marker (AM, PM)
3056  *
3057  */
3058 INT32 WINAPI
3059 GetTimeFormat32A(LCID locale,        /* in  */
3060                  DWORD flags,        /* in  */
3061                  LPSYSTEMTIME xtime, /* in  */
3062                  LPCSTR format,      /* in  */
3063                  LPSTR timestr,      /* out */
3064                  INT32 timelen       /* in  */)
3065 { char format_buf[40];
3066   LPCSTR thisformat;
3067   SYSTEMTIME t;
3068   LPSYSTEMTIME thistime;
3069   LCID thislocale=0;
3070   DWORD thisflags=LOCALE_STIMEFORMAT; /* standart timeformat */
3071   INT32 ret;
3072
3073   TRACE(ole,"GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,xtime,format,timestr,timelen);
3074
3075   thislocale = OLE2NLS_CheckLocale ( locale );
3076
3077   if ( flags & (TIME_NOTIMEMARKER | TIME_FORCE24HOURFORMAT ))
3078   { FIXME(ole,"TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
3079   }
3080
3081   flags &= (TIME_NOSECONDS | TIME_NOMINUTESORSECONDS); /* mask for OLE_GetFormatA*/
3082
3083   if (format == NULL)
3084   { if (flags & LOCALE_NOUSEROVERRIDE)  /*use system default*/
3085     { thislocale = GetSystemDefaultLCID();
3086     }
3087     GetLocaleInfo32A(thislocale, thisflags, format_buf, sizeof(format_buf));
3088     thisformat = format_buf;
3089   }
3090   else
3091   { thisformat = format;
3092   }
3093
3094   if (xtime == NULL) /* NULL means use the current local time*/
3095   { GetSystemTime(&t);
3096     thistime = &t;
3097   }
3098   else
3099   { thistime = xtime;
3100   }
3101   ret = OLE_GetFormatA(thislocale, thisflags, flags, thistime, thisformat,
3102                          timestr, timelen);
3103   SetLastError(ret);
3104   return ret;
3105 }
3106
3107
3108 /******************************************************************************
3109  *              GetTimeFormat32W        [KERNEL32.423]
3110  * Makes a Unicode string of the time
3111  */
3112 INT32 WINAPI
3113 GetTimeFormat32W(LCID locale,        /* in  */
3114                  DWORD flags,        /* in  */
3115                  LPSYSTEMTIME xtime, /* in  */
3116                  LPCWSTR format,     /* in  */
3117                  LPWSTR timestr,     /* out */
3118                  INT32 timelen       /* in  */)
3119 {       WCHAR format_buf[40];
3120         LPCWSTR thisformat;
3121         SYSTEMTIME t;
3122         LPSYSTEMTIME thistime;
3123         LCID thislocale=0;
3124         DWORD thisflags=LOCALE_STIMEFORMAT; /* standart timeformat */
3125         INT32 ret;
3126
3127         TRACE(ole,"GetTimeFormat(0x%04lx,0x%08lx,%p,%s,%p,%d)\n",locale,flags,
3128         xtime,debugstr_w(format),timestr,timelen);
3129
3130         thislocale = OLE2NLS_CheckLocale ( locale );
3131
3132         if ( flags & (TIME_NOTIMEMARKER | TIME_FORCE24HOURFORMAT ))
3133         { FIXME(ole,"TIME_NOTIMEMARKER or TIME_FORCE24HOURFORMAT not implemented\n");
3134         }
3135
3136         flags &= (TIME_NOSECONDS | TIME_NOMINUTESORSECONDS); /* mask for OLE_GetFormatA*/
3137
3138         if (format == NULL)
3139         { if (flags & LOCALE_NOUSEROVERRIDE)  /*use system default*/
3140           { thislocale = GetSystemDefaultLCID();
3141           }
3142           GetLocaleInfo32W(thislocale, thisflags, format_buf, 40);
3143           thisformat = format_buf;
3144         }
3145         else
3146         { thisformat = format;
3147         }
3148
3149         if (xtime == NULL) /* NULL means use the current local time*/
3150         { GetSystemTime(&t);
3151           thistime = &t;
3152         }
3153         else
3154         { thistime = xtime;
3155         }
3156
3157         ret = OLE_GetFormatW(thislocale, thisflags, flags, thistime, thisformat,
3158                          timestr, timelen);
3159         SetLastError(ret);
3160         return ret;
3161 }