dlls/msvcirt/msvcirt.c

   1 /*
   2  * Copyright (C) 2007 Alexandre Julliard
   3  * Copyright (C) 2015-2016 Iván Matellanes
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21
  22 #include <fcntl.h>
  23 #include <io.h>
  24 #include <share.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <sys/stat.h>
  28
  29 #include "msvcirt.h"
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msvcirt);
  35
  36 #define RESERVE_SIZE 512
  37 #define STATEBUF_SIZE 8
  38
  39 /* ?sh_none@filebuf@@2HB */
  40 const int filebuf_sh_none = 0x800;
  41 /* ?sh_read@filebuf@@2HB */
  42 const int filebuf_sh_read = 0xa00;
  43 /* ?sh_write@filebuf@@2HB */
  44 const int filebuf_sh_write = 0xc00;
  45 /* ?openprot@filebuf@@2HB */
  46 const int filebuf_openprot = 420;
  47 /* ?binary@filebuf@@2HB */
  48 const int filebuf_binary = _O_BINARY;
  49 /* ?text@filebuf@@2HB */
  50 const int filebuf_text = _O_TEXT;
  51
  52 /* ?adjustfield@ios@@2JB */
  53 const LONG ios_adjustfield = FLAGS_left | FLAGS_right | FLAGS_internal;
  54 /* ?basefield@ios@@2JB */
  55 const LONG ios_basefield = FLAGS_dec | FLAGS_oct | FLAGS_hex;
  56 /* ?floatfield@ios@@2JB */
  57 const LONG ios_floatfield = FLAGS_scientific | FLAGS_fixed;
  58 /* ?fLockcInit@ios@@0HA */
  59 /* FIXME: should be initialized to 0 and increased on construction of cin, cout, cerr and clog */
  60 int ios_fLockcInit = 4;
  61 /* ?x_lockc@ios@@0U_CRT_CRITICAL_SECTION@@A */
  62 extern CRITICAL_SECTION ios_static_lock;
  63 CRITICAL_SECTION_DEBUG ios_static_lock_debug =
  64 {
  65     0, 0, &ios_static_lock,
  66     { &ios_static_lock_debug.ProcessLocksList, &ios_static_lock_debug.ProcessLocksList },
  67       0, 0, { (DWORD_PTR)(__FILE__ ": ios_static_lock") }
  68 };
  69 CRITICAL_SECTION ios_static_lock = { &ios_static_lock_debug, -1, 0, 0, 0, 0 };
  70 /* ?x_maxbit@ios@@0JA */
  71 LONG ios_maxbit = 0x8000;
  72 /* ?x_curindex@ios@@0HA */
  73 int ios_curindex = -1;
  74 /* ?x_statebuf@ios@@0PAJA */
  75 LONG ios_statebuf[STATEBUF_SIZE] = {0};
  76
  77 /* class streambuf */
  78 typedef struct {
  79     const vtable_ptr *vtable;
  80     int allocated;
  81     int unbuffered;
  82     int stored_char;
  83     char *base;
  84     char *ebuf;
  85     char *pbase;
  86     char *pptr;
  87     char *epptr;
  88     char *eback;
  89     char *gptr;
  90     char *egptr;
  91     int do_lock;
  92     CRITICAL_SECTION lock;
  93 } streambuf;
  94
  95 void __thiscall streambuf_setb(streambuf*, char*, char*, int);
  96 streambuf* __thiscall streambuf_setbuf(streambuf*, char*, int);
  97 void __thiscall streambuf_setg(streambuf*, char*, char*, char*);
  98 void __thiscall streambuf_setp(streambuf*, char*, char*);
  99
 100 /* class filebuf */
 101 typedef struct {
 102     streambuf base;
 103     filedesc fd;
 104     int close;
 105 } filebuf;
 106
 107 filebuf* __thiscall filebuf_close(filebuf*);
 108
 109 /* class strstreambuf */
 110 typedef struct {
 111     streambuf base;
 112     int dynamic;
 113     int increase;
 114     int unknown;
 115     int constant;
 116     allocFunction f_alloc;
 117     freeFunction f_free;
 118 } strstreambuf;
 119
 120 /* class stdiobuf */
 121 typedef struct {
 122     streambuf base;
 123     FILE *file;
 124 } stdiobuf;
 125
 126 /* class ios */
 127 struct _ostream;
 128 typedef struct {
 129     const vtable_ptr *vtable;
 130     streambuf *sb;
 131     ios_io_state state;
 132     int special[4];
 133     int delbuf;
 134     struct _ostream *tie;
 135     ios_flags flags;
 136     int precision;
 137     char fill;
 138     int width;
 139     int do_lock;
 140     CRITICAL_SECTION lock;
 141 } ios;
 142
 143 ios* __thiscall ios_assign(ios*, const ios*);
 144 int __thiscall ios_fail(const ios*);
 145 void __cdecl ios_lock(ios*);
 146 void __cdecl ios_lockc(void);
 147 LONG __thiscall ios_setf_mask(ios*, LONG, LONG);
 148 void __cdecl ios_unlock(ios*);
 149 void __cdecl ios_unlockc(void);
 150
 151 /* class ostream */
 152 typedef struct _ostream {
 153     const int *vbtable;
 154     int unknown;
 155 } ostream;
 156
 157 /* class istream */
 158 typedef struct {
 159     const int *vbtable;
 160     int extract_delim;
 161     int count;
 162 } istream;
 163
 164 /* ??_7streambuf@@6B@ */
 165 extern const vtable_ptr MSVCP_streambuf_vtable;
 166 /* ??_7filebuf@@6B@ */
 167 extern const vtable_ptr MSVCP_filebuf_vtable;
 168 /* ??_7strstreambuf@@6B@ */
 169 extern const vtable_ptr MSVCP_strstreambuf_vtable;
 170 /* ??_7stdiobuf@@6B@ */
 171 extern const vtable_ptr MSVCP_stdiobuf_vtable;
 172 /* ??_7ios@@6B@ */
 173 extern const vtable_ptr MSVCP_ios_vtable;
 174 /* ??_7ostream@@6B@ */
 175 extern const vtable_ptr MSVCP_ostream_vtable;
 176 /* ??_7istream@@6B@ */
 177 extern const vtable_ptr MSVCP_istream_vtable;
 178
 179 #ifndef __GNUC__
 180 void __asm_dummy_vtables(void) {
 181 #endif
 182     __ASM_VTABLE(streambuf,
 183             VTABLE_ADD_FUNC(streambuf_vector_dtor)
 184             VTABLE_ADD_FUNC(streambuf_sync)
 185             VTABLE_ADD_FUNC(streambuf_setbuf)
 186             VTABLE_ADD_FUNC(streambuf_seekoff)
 187             VTABLE_ADD_FUNC(streambuf_seekpos)
 188             VTABLE_ADD_FUNC(streambuf_xsputn)
 189             VTABLE_ADD_FUNC(streambuf_xsgetn)
 190             VTABLE_ADD_FUNC(streambuf_overflow)
 191             VTABLE_ADD_FUNC(streambuf_underflow)
 192             VTABLE_ADD_FUNC(streambuf_pbackfail)
 193             VTABLE_ADD_FUNC(streambuf_doallocate));
 194     __ASM_VTABLE(filebuf,
 195             VTABLE_ADD_FUNC(filebuf_vector_dtor)
 196             VTABLE_ADD_FUNC(filebuf_sync)
 197             VTABLE_ADD_FUNC(filebuf_setbuf)
 198             VTABLE_ADD_FUNC(filebuf_seekoff)
 199             VTABLE_ADD_FUNC(streambuf_seekpos)
 200             VTABLE_ADD_FUNC(streambuf_xsputn)
 201             VTABLE_ADD_FUNC(streambuf_xsgetn)
 202             VTABLE_ADD_FUNC(filebuf_overflow)
 203             VTABLE_ADD_FUNC(filebuf_underflow)
 204             VTABLE_ADD_FUNC(streambuf_pbackfail)
 205             VTABLE_ADD_FUNC(streambuf_doallocate));
 206     __ASM_VTABLE(strstreambuf,
 207             VTABLE_ADD_FUNC(strstreambuf_vector_dtor)
 208             VTABLE_ADD_FUNC(strstreambuf_sync)
 209             VTABLE_ADD_FUNC(strstreambuf_setbuf)
 210             VTABLE_ADD_FUNC(strstreambuf_seekoff)
 211             VTABLE_ADD_FUNC(streambuf_seekpos)
 212             VTABLE_ADD_FUNC(streambuf_xsputn)
 213             VTABLE_ADD_FUNC(streambuf_xsgetn)
 214             VTABLE_ADD_FUNC(strstreambuf_overflow)
 215             VTABLE_ADD_FUNC(strstreambuf_underflow)
 216             VTABLE_ADD_FUNC(streambuf_pbackfail)
 217             VTABLE_ADD_FUNC(strstreambuf_doallocate));
 218     __ASM_VTABLE(stdiobuf,
 219             VTABLE_ADD_FUNC(stdiobuf_vector_dtor)
 220             VTABLE_ADD_FUNC(stdiobuf_sync)
 221             VTABLE_ADD_FUNC(streambuf_setbuf)
 222             VTABLE_ADD_FUNC(stdiobuf_seekoff)
 223             VTABLE_ADD_FUNC(streambuf_seekpos)
 224             VTABLE_ADD_FUNC(streambuf_xsputn)
 225             VTABLE_ADD_FUNC(streambuf_xsgetn)
 226             VTABLE_ADD_FUNC(stdiobuf_overflow)
 227             VTABLE_ADD_FUNC(stdiobuf_underflow)
 228             VTABLE_ADD_FUNC(stdiobuf_pbackfail)
 229             VTABLE_ADD_FUNC(streambuf_doallocate));
 230     __ASM_VTABLE(ios,
 231             VTABLE_ADD_FUNC(ios_vector_dtor));
 232     __ASM_VTABLE(ostream,
 233             VTABLE_ADD_FUNC(ostream_vector_dtor));
 234     __ASM_VTABLE(istream,
 235             VTABLE_ADD_FUNC(istream_vector_dtor));
 236 #ifndef __GNUC__
 237 }
 238 #endif
 239
 240 #define ALIGNED_SIZE(size, alignment) (((size)+((alignment)-1))/(alignment)*(alignment))
 241 #define VBTABLE_ENTRY(class, offset, vbase) ALIGNED_SIZE(sizeof(class), TYPE_ALIGNMENT(vbase))-offset
 242
 243 /* ??_8ostream@@7B@ */
 244 const int ostream_vbtable[] = {0, VBTABLE_ENTRY(ostream, FIELD_OFFSET(ostream, vbtable), ios)};
 245 /* ??_8istream@@7B@ */
 246 const int istream_vbtable[] = {0, VBTABLE_ENTRY(istream, FIELD_OFFSET(istream, vbtable), ios)};
 247
 248 DEFINE_RTTI_DATA0(streambuf, 0, ".?AVstreambuf@@")
 249 DEFINE_RTTI_DATA1(filebuf, 0, &streambuf_rtti_base_descriptor, ".?AVfilebuf@@")
 250 DEFINE_RTTI_DATA1(strstreambuf, 0, &streambuf_rtti_base_descriptor, ".?AVstrstreambuf@@")
 251 DEFINE_RTTI_DATA1(stdiobuf, 0, &streambuf_rtti_base_descriptor, ".?AVstdiobuf@@")
 252 DEFINE_RTTI_DATA0(ios, 0, ".?AVios@@")
 253 DEFINE_RTTI_DATA1(ostream, sizeof(ostream), &ios_rtti_base_descriptor, ".?AVostream@@")
 254 DEFINE_RTTI_DATA1(istream, sizeof(istream), &ios_rtti_base_descriptor, ".?AVistream@@")
 255
 256 /* ??0streambuf@@IAE@PADH@Z */
 257 /* ??0streambuf@@IEAA@PEADH@Z */
 258 DEFINE_THISCALL_WRAPPER(streambuf_reserve_ctor, 12)
 259 streambuf* __thiscall streambuf_reserve_ctor(streambuf *this, char *buffer, int length)
 260 {
 261     TRACE("(%p %p %d)\n", this, buffer, length);
 262     this->vtable = &MSVCP_streambuf_vtable;
 263     this->allocated = 0;
 264     this->stored_char = EOF;
 265     this->do_lock = -1;
 266     this->base = NULL;
 267     streambuf_setbuf(this, buffer, length);
 268     streambuf_setg(this, NULL, NULL, NULL);
 269     streambuf_setp(this, NULL, NULL);
 270     InitializeCriticalSection(&this->lock);
 271     return this;
 272 }
 273
 274 /* ??0streambuf@@IAE@XZ */
 275 /* ??0streambuf@@IEAA@XZ */
 276 DEFINE_THISCALL_WRAPPER(streambuf_ctor, 4)
 277 streambuf* __thiscall streambuf_ctor(streambuf *this)
 278 {
 279     streambuf_reserve_ctor(this, NULL, 0);
 280     this->unbuffered = 0;
 281     return this;
 282 }
 283
 284 /* ??0streambuf@@QAE@ABV0@@Z */
 285 /* ??0streambuf@@QEAA@AEBV0@@Z */
 286 DEFINE_THISCALL_WRAPPER(streambuf_copy_ctor, 8)
 287 streambuf* __thiscall streambuf_copy_ctor(streambuf *this, const streambuf *copy)
 288 {
 289     TRACE("(%p %p)\n", this, copy);
 290     *this = *copy;
 291     this->vtable = &MSVCP_streambuf_vtable;
 292     return this;
 293 }
 294
 295 /* ??1streambuf@@UAE@XZ */
 296 /* ??1streambuf@@UEAA@XZ */
 297 DEFINE_THISCALL_WRAPPER(streambuf_dtor, 4)
 298 void __thiscall streambuf_dtor(streambuf *this)
 299 {
 300     TRACE("(%p)\n", this);
 301     if (this->allocated)
 302         MSVCRT_operator_delete(this->base);
 303     DeleteCriticalSection(&this->lock);
 304 }
 305
 306 /* ??4streambuf@@QAEAAV0@ABV0@@Z */
 307 /* ??4streambuf@@QEAAAEAV0@AEBV0@@Z */
 308 DEFINE_THISCALL_WRAPPER(streambuf_assign, 8)
 309 streambuf* __thiscall streambuf_assign(streambuf *this, const streambuf *rhs)
 310 {
 311     streambuf_dtor(this);
 312     return streambuf_copy_ctor(this, rhs);
 313 }
 314
 315 /* ??_Estreambuf@@UAEPAXI@Z */
 316 DEFINE_THISCALL_WRAPPER(streambuf_vector_dtor, 8)
 317 #define call_streambuf_vector_dtor(this, flags) CALL_VTBL_FUNC(this, 0,\
 318         streambuf*, (streambuf*, unsigned int), (this, flags))
 319 streambuf* __thiscall streambuf_vector_dtor(streambuf *this, unsigned int flags)
 320 {
 321     TRACE("(%p %x)\n", this, flags);
 322     if (flags & 2) {
 323         /* we have an array, with the number of elements stored before the first object */
 324         INT_PTR i, *ptr = (INT_PTR *)this-1;
 325
 326         for (i = *ptr-1; i >= 0; i--)
 327             streambuf_dtor(this+i);
 328         MSVCRT_operator_delete(ptr);
 329     } else {
 330         streambuf_dtor(this);
 331         if (flags & 1)
 332             MSVCRT_operator_delete(this);
 333     }
 334     return this;
 335 }
 336
 337 /* ??_Gstreambuf@@UAEPAXI@Z */
 338 DEFINE_THISCALL_WRAPPER(streambuf_scalar_dtor, 8)
 339 streambuf* __thiscall streambuf_scalar_dtor(streambuf *this, unsigned int flags)
 340 {
 341     TRACE("(%p %x)\n", this, flags);
 342     streambuf_dtor(this);
 343     if (flags & 1) MSVCRT_operator_delete(this);
 344     return this;
 345 }
 346
 347 /* ?doallocate@streambuf@@MAEHXZ */
 348 /* ?doallocate@streambuf@@MEAAHXZ */
 349 DEFINE_THISCALL_WRAPPER(streambuf_doallocate, 4)
 350 #define call_streambuf_doallocate(this) CALL_VTBL_FUNC(this, 40, int, (streambuf*), (this))
 351 int __thiscall streambuf_doallocate(streambuf *this)
 352 {
 353     char *reserve;
 354
 355     TRACE("(%p)\n", this);
 356     reserve = MSVCRT_operator_new(RESERVE_SIZE);
 357     if (!reserve)
 358         return EOF;
 359
 360     streambuf_setb(this, reserve, reserve + RESERVE_SIZE, 1);
 361     return 1;
 362 }
 363
 364 /* ?allocate@streambuf@@IAEHXZ */
 365 /* ?allocate@streambuf@@IEAAHXZ */
 366 DEFINE_THISCALL_WRAPPER(streambuf_allocate, 4)
 367 int __thiscall streambuf_allocate(streambuf *this)
 368 {
 369     TRACE("(%p)\n", this);
 370     if (this->base != NULL || this->unbuffered)
 371         return 0;
 372     return call_streambuf_doallocate(this);
 373 }
 374
 375 /* ?base@streambuf@@IBEPADXZ */
 376 /* ?base@streambuf@@IEBAPEADXZ */
 377 DEFINE_THISCALL_WRAPPER(streambuf_base, 4)
 378 char* __thiscall streambuf_base(const streambuf *this)
 379 {
 380     TRACE("(%p)\n", this);
 381     return this->base;
 382 }
 383
 384 /* ?blen@streambuf@@IBEHXZ */
 385 /* ?blen@streambuf@@IEBAHXZ */
 386 DEFINE_THISCALL_WRAPPER(streambuf_blen, 4)
 387 int __thiscall streambuf_blen(const streambuf *this)
 388 {
 389     TRACE("(%p)\n", this);
 390     return this->ebuf - this->base;
 391 }
 392
 393 /* ?eback@streambuf@@IBEPADXZ */
 394 /* ?eback@streambuf@@IEBAPEADXZ */
 395 DEFINE_THISCALL_WRAPPER(streambuf_eback, 4)
 396 char* __thiscall streambuf_eback(const streambuf *this)
 397 {
 398     TRACE("(%p)\n", this);
 399     return this->eback;
 400 }
 401
 402 /* ?ebuf@streambuf@@IBEPADXZ */
 403 /* ?ebuf@streambuf@@IEBAPEADXZ */
 404 DEFINE_THISCALL_WRAPPER(streambuf_ebuf, 4)
 405 char* __thiscall streambuf_ebuf(const streambuf *this)
 406 {
 407     TRACE("(%p)\n", this);
 408     return this->ebuf;
 409 }
 410
 411 /* ?egptr@streambuf@@IBEPADXZ */
 412 /* ?egptr@streambuf@@IEBAPEADXZ */
 413 DEFINE_THISCALL_WRAPPER(streambuf_egptr, 4)
 414 char* __thiscall streambuf_egptr(const streambuf *this)
 415 {
 416     TRACE("(%p)\n", this);
 417     return this->egptr;
 418 }
 419
 420 /* ?epptr@streambuf@@IBEPADXZ */
 421 /* ?epptr@streambuf@@IEBAPEADXZ */
 422 DEFINE_THISCALL_WRAPPER(streambuf_epptr, 4)
 423 char* __thiscall streambuf_epptr(const streambuf *this)
 424 {
 425     TRACE("(%p)\n", this);
 426     return this->epptr;
 427 }
 428
 429 /* ?gptr@streambuf@@IBEPADXZ */
 430 /* ?gptr@streambuf@@IEBAPEADXZ */
 431 DEFINE_THISCALL_WRAPPER(streambuf_gptr, 4)
 432 char* __thiscall streambuf_gptr(const streambuf *this)
 433 {
 434     TRACE("(%p)\n", this);
 435     return this->gptr;
 436 }
 437
 438 /* ?pbase@streambuf@@IBEPADXZ */
 439 /* ?pbase@streambuf@@IEBAPEADXZ */
 440 DEFINE_THISCALL_WRAPPER(streambuf_pbase, 4)
 441 char* __thiscall streambuf_pbase(const streambuf *this)
 442 {
 443     TRACE("(%p)\n", this);
 444     return this->pbase;
 445 }
 446
 447 /* ?pptr@streambuf@@IBEPADXZ */
 448 /* ?pptr@streambuf@@IEBAPEADXZ */
 449 DEFINE_THISCALL_WRAPPER(streambuf_pptr, 4)
 450 char* __thiscall streambuf_pptr(const streambuf *this)
 451 {
 452     TRACE("(%p)\n", this);
 453     return this->pptr;
 454 }
 455
 456 /* ?clrlock@streambuf@@QAEXXZ */
 457 /* ?clrlock@streambuf@@QEAAXXZ */
 458 DEFINE_THISCALL_WRAPPER(streambuf_clrlock, 4)
 459 void __thiscall streambuf_clrlock(streambuf *this)
 460 {
 461     TRACE("(%p)\n", this);
 462     if (this->do_lock <= 0)
 463         this->do_lock++;
 464 }
 465
 466 /* ?lock@streambuf@@QAEXXZ */
 467 /* ?lock@streambuf@@QEAAXXZ */
 468 DEFINE_THISCALL_WRAPPER(streambuf_lock, 4)
 469 void __thiscall streambuf_lock(streambuf *this)
 470 {
 471     TRACE("(%p)\n", this);
 472     if (this->do_lock < 0)
 473         EnterCriticalSection(&this->lock);
 474 }
 475
 476 /* ?lockptr@streambuf@@IAEPAU_CRT_CRITICAL_SECTION@@XZ */
 477 /* ?lockptr@streambuf@@IEAAPEAU_CRT_CRITICAL_SECTION@@XZ */
 478 DEFINE_THISCALL_WRAPPER(streambuf_lockptr, 4)
 479 CRITICAL_SECTION* __thiscall streambuf_lockptr(streambuf *this)
 480 {
 481     TRACE("(%p)\n", this);
 482     return &this->lock;
 483 }
 484
 485 /* ?gbump@streambuf@@IAEXH@Z */
 486 /* ?gbump@streambuf@@IEAAXH@Z */
 487 DEFINE_THISCALL_WRAPPER(streambuf_gbump, 8)
 488 void __thiscall streambuf_gbump(streambuf *this, int count)
 489 {
 490     TRACE("(%p %d)\n", this, count);
 491     this->gptr += count;
 492 }
 493
 494 /* ?pbump@streambuf@@IAEXH@Z */
 495 /* ?pbump@streambuf@@IEAAXH@Z */
 496 DEFINE_THISCALL_WRAPPER(streambuf_pbump, 8)
 497 void __thiscall streambuf_pbump(streambuf *this, int count)
 498 {
 499     TRACE("(%p %d)\n", this, count);
 500     this->pptr += count;
 501 }
 502
 503 /* ?in_avail@streambuf@@QBEHXZ */
 504 /* ?in_avail@streambuf@@QEBAHXZ */
 505 DEFINE_THISCALL_WRAPPER(streambuf_in_avail, 4)
 506 int __thiscall streambuf_in_avail(const streambuf *this)
 507 {
 508     TRACE("(%p)\n", this);
 509     return this->egptr - this->gptr;
 510 }
 511
 512 /* ?out_waiting@streambuf@@QBEHXZ */
 513 /* ?out_waiting@streambuf@@QEBAHXZ */
 514 DEFINE_THISCALL_WRAPPER(streambuf_out_waiting, 4)
 515 int __thiscall streambuf_out_waiting(const streambuf *this)
 516 {
 517     TRACE("(%p)\n", this);
 518     return this->pptr - this->pbase;
 519 }
 520
 521 /* Unexported */
 522 DEFINE_THISCALL_WRAPPER(streambuf_overflow, 8)
 523 #define call_streambuf_overflow(this, c) CALL_VTBL_FUNC(this, 28, int, (streambuf*, int), (this, c))
 524 int __thiscall streambuf_overflow(streambuf *this, int c)
 525 {
 526     ERR("overflow is not implemented in streambuf\n");
 527     return EOF;
 528 }
 529
 530 /* ?seekoff@streambuf@@UAEJJW4seek_dir@ios@@H@Z */
 531 /* ?seekoff@streambuf@@UEAAJJW4seek_dir@ios@@H@Z */
 532 DEFINE_THISCALL_WRAPPER(streambuf_seekoff, 16)
 533 #define call_streambuf_seekoff(this, off, dir, mode) CALL_VTBL_FUNC(this, 12, streampos, (streambuf*, streamoff, ios_seek_dir, int), (this, off, dir, mode))
 534 streampos __thiscall streambuf_seekoff(streambuf *this, streamoff offset, ios_seek_dir dir, int mode)
 535 {
 536     TRACE("(%p %d %d %d)\n", this, offset, dir, mode);
 537     return EOF;
 538 }
 539
 540 /* ?seekpos@streambuf@@UAEJJH@Z */
 541 /* ?seekpos@streambuf@@UEAAJJH@Z */
 542 DEFINE_THISCALL_WRAPPER(streambuf_seekpos, 12)
 543 streampos __thiscall streambuf_seekpos(streambuf *this, streampos pos, int mode)
 544 {
 545     TRACE("(%p %d %d)\n", this, pos, mode);
 546     return call_streambuf_seekoff(this, pos, SEEKDIR_beg, mode);
 547 }
 548
 549 /* ?pbackfail@streambuf@@UAEHH@Z */
 550 /* ?pbackfail@streambuf@@UEAAHH@Z */
 551 DEFINE_THISCALL_WRAPPER(streambuf_pbackfail, 8)
 552 #define call_streambuf_pbackfail(this, c) CALL_VTBL_FUNC(this, 36, int, (streambuf*, int), (this, c))
 553 int __thiscall streambuf_pbackfail(streambuf *this, int c)
 554 {
 555     TRACE("(%p %d)\n", this, c);
 556     if (this->gptr > this->eback)
 557         return *--this->gptr = c;
 558     if (call_streambuf_seekoff(this, -1, SEEKDIR_cur, OPENMODE_in) == EOF)
 559         return EOF;
 560     if (!this->unbuffered && this->egptr) {
 561         /* 'c' should be the next character read */
 562         memmove(this->gptr + 1, this->gptr, this->egptr - this->gptr - 1);
 563         *this->gptr = c;
 564     }
 565     return c;
 566 }
 567
 568 /* ?setb@streambuf@@IAEXPAD0H@Z */
 569 /* ?setb@streambuf@@IEAAXPEAD0H@Z */
 570 DEFINE_THISCALL_WRAPPER(streambuf_setb, 16)
 571 void __thiscall streambuf_setb(streambuf *this, char *ba, char *eb, int delete)
 572 {
 573     TRACE("(%p %p %p %d)\n", this, ba, eb, delete);
 574     if (this->allocated)
 575         MSVCRT_operator_delete(this->base);
 576     this->allocated = delete;
 577     this->base = ba;
 578     this->ebuf = eb;
 579 }
 580
 581 /* ?setbuf@streambuf@@UAEPAV1@PADH@Z */
 582 /* ?setbuf@streambuf@@UEAAPEAV1@PEADH@Z */
 583 DEFINE_THISCALL_WRAPPER(streambuf_setbuf, 12)
 584 streambuf* __thiscall streambuf_setbuf(streambuf *this, char *buffer, int length)
 585 {
 586     TRACE("(%p %p %d)\n", this, buffer, length);
 587     if (this->base != NULL)
 588         return NULL;
 589
 590     if (buffer == NULL || !length) {
 591         this->unbuffered = 1;
 592         this->base = this->ebuf = NULL;
 593     } else {
 594         this->unbuffered = 0;
 595         this->base = buffer;
 596         this->ebuf = buffer + length;
 597     }
 598     return this;
 599 }
 600
 601 /* ?setg@streambuf@@IAEXPAD00@Z */
 602 /* ?setg@streambuf@@IEAAXPEAD00@Z */
 603 DEFINE_THISCALL_WRAPPER(streambuf_setg, 16)
 604 void __thiscall streambuf_setg(streambuf *this, char *ek, char *gp, char *eg)
 605 {
 606     TRACE("(%p %p %p %p)\n", this, ek, gp, eg);
 607     this->eback = ek;
 608     this->gptr = gp;
 609     this->egptr = eg;
 610 }
 611
 612 /* ?setlock@streambuf@@QAEXXZ */
 613 /* ?setlock@streambuf@@QEAAXXZ */
 614 DEFINE_THISCALL_WRAPPER(streambuf_setlock, 4)
 615 void __thiscall streambuf_setlock(streambuf *this)
 616 {
 617     TRACE("(%p)\n", this);
 618     this->do_lock--;
 619 }
 620
 621 /* ?setp@streambuf@@IAEXPAD0@Z */
 622 /* ?setp@streambuf@@IEAAXPEAD0@Z */
 623 DEFINE_THISCALL_WRAPPER(streambuf_setp, 12)
 624 void __thiscall streambuf_setp(streambuf *this, char *pb, char *ep)
 625 {
 626     TRACE("(%p %p %p)\n", this, pb, ep);
 627     this->pbase = this->pptr = pb;
 628     this->epptr = ep;
 629 }
 630
 631 /* ?sync@streambuf@@UAEHXZ */
 632 /* ?sync@streambuf@@UEAAHXZ */
 633 DEFINE_THISCALL_WRAPPER(streambuf_sync, 4)
 634 #define call_streambuf_sync(this) CALL_VTBL_FUNC(this, 4, int, (streambuf*), (this))
 635 int __thiscall streambuf_sync(streambuf *this)
 636 {
 637     TRACE("(%p)\n", this);
 638     return (this->gptr >= this->egptr && this->pbase >= this->pptr) ? 0 : EOF;
 639 }
 640
 641 /* ?unbuffered@streambuf@@IAEXH@Z */
 642 /* ?unbuffered@streambuf@@IEAAXH@Z */
 643 DEFINE_THISCALL_WRAPPER(streambuf_unbuffered_set, 8)
 644 void __thiscall streambuf_unbuffered_set(streambuf *this, int buf)
 645 {
 646     TRACE("(%p %d)\n", this, buf);
 647     this->unbuffered = buf;
 648 }
 649
 650 /* ?unbuffered@streambuf@@IBEHXZ */
 651 /* ?unbuffered@streambuf@@IEBAHXZ */
 652 DEFINE_THISCALL_WRAPPER(streambuf_unbuffered_get, 4)
 653 int __thiscall streambuf_unbuffered_get(const streambuf *this)
 654 {
 655     TRACE("(%p)\n", this);
 656     return this->unbuffered;
 657 }
 658
 659 /* Unexported */
 660 DEFINE_THISCALL_WRAPPER(streambuf_underflow, 4)
 661 #define call_streambuf_underflow(this) CALL_VTBL_FUNC(this, 32, int, (streambuf*), (this))
 662 int __thiscall streambuf_underflow(streambuf *this)
 663 {
 664     ERR("underflow is not implemented in streambuf\n");
 665     return EOF;
 666 }
 667
 668 /* ?unlock@streambuf@@QAEXXZ */
 669 /* ?unlock@streambuf@@QEAAXXZ */
 670 DEFINE_THISCALL_WRAPPER(streambuf_unlock, 4)
 671 void __thiscall streambuf_unlock(streambuf *this)
 672 {
 673     TRACE("(%p)\n", this);
 674     if (this->do_lock < 0)
 675         LeaveCriticalSection(&this->lock);
 676 }
 677
 678 /* ?xsgetn@streambuf@@UAEHPADH@Z */
 679 /* ?xsgetn@streambuf@@UEAAHPEADH@Z */
 680 DEFINE_THISCALL_WRAPPER(streambuf_xsgetn, 12)
 681 #define call_streambuf_xsgetn(this, buffer, count) CALL_VTBL_FUNC(this, 24, int, (streambuf*, char*, int), (this, buffer, count))
 682 int __thiscall streambuf_xsgetn(streambuf *this, char *buffer, int count)
 683 {
 684     int copied = 0, chunk;
 685
 686     TRACE("(%p %p %d)\n", this, buffer, count);
 687
 688     if (this->unbuffered) {
 689         if (this->stored_char == EOF)
 690             this->stored_char = call_streambuf_underflow(this);
 691         while (copied < count && this->stored_char != EOF) {
 692             buffer[copied++] = this->stored_char;
 693             this->stored_char = call_streambuf_underflow(this);
 694         }
 695     } else {
 696         while (copied < count) {
 697             if (call_streambuf_underflow(this) == EOF)
 698                 break;
 699             chunk = this->egptr - this->gptr;
 700             if (chunk > count - copied)
 701                 chunk = count - copied;
 702             memcpy(buffer+copied, this->gptr, chunk);
 703             this->gptr += chunk;
 704             copied += chunk;
 705         }
 706     }
 707     return copied;
 708 }
 709
 710 /* ?xsputn@streambuf@@UAEHPBDH@Z */
 711 /* ?xsputn@streambuf@@UEAAHPEBDH@Z */
 712 DEFINE_THISCALL_WRAPPER(streambuf_xsputn, 12)
 713 #define call_streambuf_xsputn(this, data, length) CALL_VTBL_FUNC(this, 20, int, (streambuf*, const char*, int), (this, data, length))
 714 int __thiscall streambuf_xsputn(streambuf *this, const char *data, int length)
 715 {
 716     int copied = 0, chunk;
 717
 718     TRACE("(%p %p %d)\n", this, data, length);
 719
 720     while (copied < length) {
 721         if (this->unbuffered || this->pptr == this->epptr) {
 722             if (call_streambuf_overflow(this, data[copied]) == EOF)
 723                 break;
 724             copied++;
 725         } else {
 726             chunk = this->epptr - this->pptr;
 727             if (chunk > length - copied)
 728                 chunk = length - copied;
 729             memcpy(this->pptr, data+copied, chunk);
 730             this->pptr += chunk;
 731             copied += chunk;
 732         }
 733     }
 734     return copied;
 735 }
 736
 737 /* ?sgetc@streambuf@@QAEHXZ */
 738 /* ?sgetc@streambuf@@QEAAHXZ */
 739 DEFINE_THISCALL_WRAPPER(streambuf_sgetc, 4)
 740 int __thiscall streambuf_sgetc(streambuf *this)
 741 {
 742     TRACE("(%p)\n", this);
 743     if (this->unbuffered) {
 744         if (this->stored_char == EOF)
 745             this->stored_char = call_streambuf_underflow(this);
 746         return this->stored_char;
 747     } else
 748         return call_streambuf_underflow(this);
 749 }
 750
 751 /* ?sputc@streambuf@@QAEHH@Z */
 752 /* ?sputc@streambuf@@QEAAHH@Z */
 753 DEFINE_THISCALL_WRAPPER(streambuf_sputc, 8)
 754 int __thiscall streambuf_sputc(streambuf *this, int ch)
 755 {
 756     TRACE("(%p %d)\n", this, ch);
 757     return (this->pptr < this->epptr) ? (unsigned char)(*this->pptr++ = ch) : call_streambuf_overflow(this, ch);
 758 }
 759
 760 /* ?sgetn@streambuf@@QAEHPADH@Z */
 761 /* ?sgetn@streambuf@@QEAAHPEADH@Z */
 762 DEFINE_THISCALL_WRAPPER(streambuf_sgetn, 12)
 763 int __thiscall streambuf_sgetn(streambuf *this, char *buffer, int count)
 764 {
 765     return call_streambuf_xsgetn(this, buffer, count);
 766 }
 767
 768 /* ?sputn@streambuf@@QAEHPBDH@Z */
 769 /* ?sputn@streambuf@@QEAAHPEBDH@Z */
 770 DEFINE_THISCALL_WRAPPER(streambuf_sputn, 12)
 771 int __thiscall streambuf_sputn(streambuf *this, const char *data, int length)
 772 {
 773     return call_streambuf_xsputn(this, data, length);
 774 }
 775
 776 /* ?snextc@streambuf@@QAEHXZ */
 777 /* ?snextc@streambuf@@QEAAHXZ */
 778 DEFINE_THISCALL_WRAPPER(streambuf_snextc, 4)
 779 int __thiscall streambuf_snextc(streambuf *this)
 780 {
 781     TRACE("(%p)\n", this);
 782     if (this->unbuffered) {
 783         if (this->stored_char == EOF)
 784             call_streambuf_underflow(this);
 785         return this->stored_char = call_streambuf_underflow(this);
 786     } else {
 787         if (this->gptr >= this->egptr)
 788             call_streambuf_underflow(this);
 789         this->gptr++;
 790         return (this->gptr < this->egptr) ? (unsigned char)(*this->gptr) : call_streambuf_underflow(this);
 791     }
 792 }
 793
 794 /* ?sbumpc@streambuf@@QAEHXZ */
 795 /* ?sbumpc@streambuf@@QEAAHXZ */
 796 DEFINE_THISCALL_WRAPPER(streambuf_sbumpc, 4)
 797 int __thiscall streambuf_sbumpc(streambuf *this)
 798 {
 799     int ret;
 800
 801     TRACE("(%p)\n", this);
 802
 803     if (this->unbuffered) {
 804         ret = this->stored_char;
 805         this->stored_char = EOF;
 806         if (ret == EOF)
 807             ret = call_streambuf_underflow(this);
 808     } else {
 809         ret = (this->gptr < this->egptr) ? (unsigned char)(*this->gptr) : call_streambuf_underflow(this);
 810         this->gptr++;
 811     }
 812     return ret;
 813 }
 814
 815 /* ?stossc@streambuf@@QAEXXZ */
 816 /* ?stossc@streambuf@@QEAAXXZ */
 817 DEFINE_THISCALL_WRAPPER(streambuf_stossc, 4)
 818 void __thiscall streambuf_stossc(streambuf *this)
 819 {
 820     TRACE("(%p)\n", this);
 821     if (this->unbuffered) {
 822         if (this->stored_char == EOF)
 823             call_streambuf_underflow(this);
 824         else
 825             this->stored_char = EOF;
 826     } else {
 827         if (this->gptr >= this->egptr)
 828             call_streambuf_underflow(this);
 829         if (this->gptr < this->egptr)
 830             this->gptr++;
 831     }
 832 }
 833
 834 /* ?sputbackc@streambuf@@QAEHD@Z */
 835 /* ?sputbackc@streambuf@@QEAAHD@Z */
 836 DEFINE_THISCALL_WRAPPER(streambuf_sputbackc, 8)
 837 int __thiscall streambuf_sputbackc(streambuf *this, char ch)
 838 {
 839     TRACE("(%p %d)\n", this, ch);
 840     return call_streambuf_pbackfail(this, ch);
 841 }
 842
 843 /* ?dbp@streambuf@@QAEXXZ */
 844 /* ?dbp@streambuf@@QEAAXXZ */
 845 DEFINE_THISCALL_WRAPPER(streambuf_dbp, 4)
 846 void __thiscall streambuf_dbp(streambuf *this)
 847 {
 848     printf("\nSTREAMBUF DEBUG INFO: this=%p, ", this);
 849     if (this->unbuffered) {
 850         printf("unbuffered\n");
 851     } else {
 852         printf("_fAlloc=%d\n", this->allocated);
 853         printf(" base()=%p, ebuf()=%p,  blen()=%d\n", this->base, this->ebuf, streambuf_blen(this));
 854         printf("pbase()=%p, pptr()=%p, epptr()=%p\n", this->pbase, this->pptr, this->epptr);
 855         printf("eback()=%p, gptr()=%p, egptr()=%p\n", this->eback, this->gptr, this->egptr);
 856     }
 857 }
 858
 859 /* ??0filebuf@@QAE@ABV0@@Z */
 860 /* ??0filebuf@@QEAA@AEBV0@@Z */
 861 DEFINE_THISCALL_WRAPPER(filebuf_copy_ctor, 8)
 862 filebuf* __thiscall filebuf_copy_ctor(filebuf* this, const filebuf *copy)
 863 {
 864     TRACE("(%p %p)\n", this, copy);
 865     *this = *copy;
 866     this->base.vtable = &MSVCP_filebuf_vtable;
 867     return this;
 868 }
 869
 870 /* ??0filebuf@@QAE@HPADH@Z */
 871 /* ??0filebuf@@QEAA@HPEADH@Z */
 872 DEFINE_THISCALL_WRAPPER(filebuf_fd_reserve_ctor, 16)
 873 filebuf* __thiscall filebuf_fd_reserve_ctor(filebuf* this, filedesc fd, char *buffer, int length)
 874 {
 875     TRACE("(%p %d %p %d)\n", this, fd, buffer, length);
 876     streambuf_reserve_ctor(&this->base, buffer, length);
 877     this->base.vtable = &MSVCP_filebuf_vtable;
 878     this->fd = fd;
 879     this->close = 0;
 880     return this;
 881 }
 882
 883 /* ??0filebuf@@QAE@H@Z */
 884 /* ??0filebuf@@QEAA@H@Z */
 885 DEFINE_THISCALL_WRAPPER(filebuf_fd_ctor, 8)
 886 filebuf* __thiscall filebuf_fd_ctor(filebuf* this, filedesc fd)
 887 {
 888     filebuf_fd_reserve_ctor(this, fd, NULL, 0);
 889     this->base.unbuffered = 0;
 890     return this;
 891 }
 892
 893 /* ??0filebuf@@QAE@XZ */
 894 /* ??0filebuf@@QEAA@XZ */
 895 DEFINE_THISCALL_WRAPPER(filebuf_ctor, 4)
 896 filebuf* __thiscall filebuf_ctor(filebuf* this)
 897 {
 898     return filebuf_fd_ctor(this, -1);
 899 }
 900
 901 /* ??1filebuf@@UAE@XZ */
 902 /* ??1filebuf@@UEAA@XZ */
 903 DEFINE_THISCALL_WRAPPER(filebuf_dtor, 4)
 904 void __thiscall filebuf_dtor(filebuf* this)
 905 {
 906     TRACE("(%p)\n", this);
 907     if (this->close)
 908         filebuf_close(this);
 909     streambuf_dtor(&this->base);
 910 }
 911
 912 /* ??4filebuf@@QAEAAV0@ABV0@@Z */
 913 /* ??4filebuf@@QEAAAEAV0@AEBV0@@Z */
 914 DEFINE_THISCALL_WRAPPER(filebuf_assign, 8)
 915 filebuf* __thiscall filebuf_assign(filebuf* this, const filebuf *rhs)
 916 {
 917     filebuf_dtor(this);
 918     return filebuf_copy_ctor(this, rhs);
 919 }
 920
 921 /* ??_Efilebuf@@UAEPAXI@Z */
 922 DEFINE_THISCALL_WRAPPER(filebuf_vector_dtor, 8)
 923 filebuf* __thiscall filebuf_vector_dtor(filebuf *this, unsigned int flags)
 924 {
 925     TRACE("(%p %x)\n", this, flags);
 926     if (flags & 2) {
 927         /* we have an array, with the number of elements stored before the first object */
 928         INT_PTR i, *ptr = (INT_PTR *)this-1;
 929
 930         for (i = *ptr-1; i >= 0; i--)
 931             filebuf_dtor(this+i);
 932         MSVCRT_operator_delete(ptr);
 933     } else {
 934         filebuf_dtor(this);
 935         if (flags & 1)
 936             MSVCRT_operator_delete(this);
 937     }
 938     return this;
 939 }
 940
 941 /* ??_Gfilebuf@@UAEPAXI@Z */
 942 DEFINE_THISCALL_WRAPPER(filebuf_scalar_dtor, 8)
 943 filebuf* __thiscall filebuf_scalar_dtor(filebuf *this, unsigned int flags)
 944 {
 945     TRACE("(%p %x)\n", this, flags);
 946     filebuf_dtor(this);
 947     if (flags & 1) MSVCRT_operator_delete(this);
 948     return this;
 949 }
 950
 951 /* ?attach@filebuf@@QAEPAV1@H@Z */
 952 /* ?attach@filebuf@@QEAAPEAV1@H@Z */
 953 DEFINE_THISCALL_WRAPPER(filebuf_attach, 8)
 954 filebuf* __thiscall filebuf_attach(filebuf *this, filedesc fd)
 955 {
 956     TRACE("(%p %d)\n", this, fd);
 957     if (this->fd != -1)
 958         return NULL;
 959
 960     streambuf_lock(&this->base);
 961     this->fd = fd;
 962     streambuf_allocate(&this->base);
 963     streambuf_unlock(&this->base);
 964     return this;
 965 }
 966
 967 /* ?close@filebuf@@QAEPAV1@XZ */
 968 /* ?close@filebuf@@QEAAPEAV1@XZ */
 969 DEFINE_THISCALL_WRAPPER(filebuf_close, 4)
 970 filebuf* __thiscall filebuf_close(filebuf *this)
 971 {
 972     filebuf *ret;
 973
 974     TRACE("(%p)\n", this);
 975     if (this->fd == -1)
 976         return NULL;
 977
 978     streambuf_lock(&this->base);
 979     if (call_streambuf_sync(&this->base) == EOF || _close(this->fd) < 0) {
 980         ret = NULL;
 981     } else {
 982         this->fd = -1;
 983         ret = this;
 984     }
 985     streambuf_unlock(&this->base);
 986     return ret;
 987 }
 988
 989 /* ?fd@filebuf@@QBEHXZ */
 990 /* ?fd@filebuf@@QEBAHXZ */
 991 DEFINE_THISCALL_WRAPPER(filebuf_fd, 4)
 992 filedesc __thiscall filebuf_fd(const filebuf *this)
 993 {
 994     TRACE("(%p)\n", this);
 995     return this->fd;
 996 }
 997
 998 /* ?is_open@filebuf@@QBEHXZ */
 999 /* ?is_open@filebuf@@QEBAHXZ */
1000 DEFINE_THISCALL_WRAPPER(filebuf_is_open, 4)
1001 int __thiscall filebuf_is_open(const filebuf *this)
1002 {
1003     TRACE("(%p)\n", this);
1004     return this->fd != -1;
1005 }
1006
1007 /* ?open@filebuf@@QAEPAV1@PBDHH@Z */
1008 /* ?open@filebuf@@QEAAPEAV1@PEBDHH@Z */
1009 DEFINE_THISCALL_WRAPPER(filebuf_open, 16)
1010 filebuf* __thiscall filebuf_open(filebuf *this, const char *name, ios_open_mode mode, int protection)
1011 {
1012     const int inout_mode[4] = {-1, _O_RDONLY, _O_WRONLY, _O_RDWR};
1013     const int share_mode[4] = {_SH_DENYRW, _SH_DENYWR, _SH_DENYRD, _SH_DENYNO};
1014     int op_flags, sh_flags, fd;
1015
1016     TRACE("(%p %s %x %x)\n", this, name, mode, protection);
1017     if (this->fd != -1)
1018         return NULL;
1019
1020     /* mode */
1021     if (mode & (OPENMODE_app|OPENMODE_trunc))
1022         mode |= OPENMODE_out;
1023     op_flags = inout_mode[mode & (OPENMODE_in|OPENMODE_out)];
1024     if (op_flags < 0)
1025         return NULL;
1026     if (mode & OPENMODE_app)
1027         op_flags |= _O_APPEND;
1028     if ((mode & OPENMODE_trunc) ||
1029             ((mode & OPENMODE_out) && !(mode & (OPENMODE_in|OPENMODE_app|OPENMODE_ate))))
1030         op_flags |= _O_TRUNC;
1031     if (!(mode & OPENMODE_nocreate))
1032         op_flags |= _O_CREAT;
1033     if (mode & OPENMODE_noreplace)
1034         op_flags |= _O_EXCL;
1035     op_flags |= (mode & OPENMODE_binary) ? _O_BINARY : _O_TEXT;
1036
1037     /* share protection */
1038     sh_flags = (protection & filebuf_sh_none) ? share_mode[(protection >> 9) & 3] : _SH_DENYNO;
1039
1040     TRACE("op_flags %x, sh_flags %x\n", op_flags, sh_flags);
1041     fd = _sopen(name, op_flags, sh_flags, _S_IREAD|_S_IWRITE);
1042     if (fd < 0)
1043         return NULL;
1044
1045     streambuf_lock(&this->base);
1046     this->close = 1;
1047     this->fd = fd;
1048     if ((mode & OPENMODE_ate) &&
1049             call_streambuf_seekoff(&this->base, 0, SEEKDIR_end, mode & (OPENMODE_in|OPENMODE_out)) == EOF) {
1050         _close(fd);
1051         this->fd = -1;
1052     }
1053     streambuf_allocate(&this->base);
1054     streambuf_unlock(&this->base);
1055     return (this->fd == -1) ? NULL : this;
1056 }
1057
1058 /* ?overflow@filebuf@@UAEHH@Z */
1059 /* ?overflow@filebuf@@UEAAHH@Z */
1060 DEFINE_THISCALL_WRAPPER(filebuf_overflow, 8)
1061 int __thiscall filebuf_overflow(filebuf *this, int c)
1062 {
1063     TRACE("(%p %d)\n", this, c);
1064     if (call_streambuf_sync(&this->base) == EOF)
1065         return EOF;
1066     if (this->base.unbuffered)
1067         return (c == EOF) ? 1 : _write(this->fd, &c, 1);
1068     if (streambuf_allocate(&this->base) == EOF)
1069         return EOF;
1070
1071     this->base.pbase = this->base.pptr = this->base.base;
1072     this->base.epptr = this->base.ebuf;
1073     if (c != EOF)
1074         *this->base.pptr++ = c;
1075     return 1;
1076 }
1077
1078 /* ?seekoff@filebuf@@UAEJJW4seek_dir@ios@@H@Z */
1079 /* ?seekoff@filebuf@@UEAAJJW4seek_dir@ios@@H@Z */
1080 DEFINE_THISCALL_WRAPPER(filebuf_seekoff, 16)
1081 streampos __thiscall filebuf_seekoff(filebuf *this, streamoff offset, ios_seek_dir dir, int mode)
1082 {
1083     TRACE("(%p %d %d %d)\n", this, offset, dir, mode);
1084     if (call_streambuf_sync(&this->base) == EOF)
1085         return EOF;
1086     return _lseek(this->fd, offset, dir);
1087 }
1088
1089 /* ?setbuf@filebuf@@UAEPAVstreambuf@@PADH@Z */
1090 /* ?setbuf@filebuf@@UEAAPEAVstreambuf@@PEADH@Z */
1091 DEFINE_THISCALL_WRAPPER(filebuf_setbuf, 12)
1092 streambuf* __thiscall filebuf_setbuf(filebuf *this, char *buffer, int length)
1093 {
1094     streambuf *ret;
1095
1096     TRACE("(%p %p %d)\n", this, buffer, length);
1097     if (this->base.base != NULL)
1098         return NULL;
1099
1100     streambuf_lock(&this->base);
1101     ret = streambuf_setbuf(&this->base, buffer, length);
1102     streambuf_unlock(&this->base);
1103     return ret;
1104 }
1105
1106 /* ?setmode@filebuf@@QAEHH@Z */
1107 /* ?setmode@filebuf@@QEAAHH@Z */
1108 DEFINE_THISCALL_WRAPPER(filebuf_setmode, 8)
1109 int __thiscall filebuf_setmode(filebuf *this, int mode)
1110 {
1111     int ret;
1112
1113     TRACE("(%p %d)\n", this, mode);
1114     if (mode != filebuf_text && mode != filebuf_binary)
1115         return -1;
1116
1117     streambuf_lock(&this->base);
1118     ret = (call_streambuf_sync(&this->base) == EOF) ? -1 : _setmode(this->fd, mode);
1119     streambuf_unlock(&this->base);
1120     return ret;
1121 }
1122
1123 /* ?sync@filebuf@@UAEHXZ */
1124 /* ?sync@filebuf@@UEAAHXZ */
1125 DEFINE_THISCALL_WRAPPER(filebuf_sync, 4)
1126 int __thiscall filebuf_sync(filebuf *this)
1127 {
1128     int count, mode;
1129     char *ptr;
1130     LONG offset;
1131
1132     TRACE("(%p)\n", this);
1133     if (this->fd == -1)
1134         return EOF;
1135     if (this->base.unbuffered)
1136         return 0;
1137
1138     /* flush output buffer */
1139     if (this->base.pptr != NULL) {
1140         count = this->base.pptr - this->base.pbase;
1141         if (count > 0 && _write(this->fd, this->base.pbase, count) != count)
1142             return EOF;
1143     }
1144     this->base.pbase = this->base.pptr = this->base.epptr = NULL;
1145     /* flush input buffer */
1146     if (this->base.egptr != NULL) {
1147         offset = this->base.egptr - this->base.gptr;
1148         if (offset > 0) {
1149             mode = _setmode(this->fd, _O_TEXT);
1150             _setmode(this->fd, mode);
1151             if (mode & _O_TEXT) {
1152                 /* in text mode, '\n' in the buffer means '\r\n' in the file */
1153                 for (ptr = this->base.gptr; ptr < this->base.egptr; ptr++)
1154                     if (*ptr == '\n')
1155                         offset++;
1156             }
1157             if (_lseek(this->fd, -offset, SEEK_CUR) < 0)
1158                 return EOF;
1159         }
1160     }
1161     this->base.eback = this->base.gptr = this->base.egptr = NULL;
1162     return 0;
1163 }
1164
1165 /* ?underflow@filebuf@@UAEHXZ */
1166 /* ?underflow@filebuf@@UEAAHXZ */
1167 DEFINE_THISCALL_WRAPPER(filebuf_underflow, 4)
1168 int __thiscall filebuf_underflow(filebuf *this)
1169 {
1170     int buffer_size, read_bytes;
1171     char c;
1172
1173     TRACE("(%p)\n", this);
1174
1175     if (this->base.unbuffered)
1176         return (_read(this->fd, &c, 1) < 1) ? EOF : (unsigned char) c;
1177
1178     if (this->base.gptr >= this->base.egptr) {
1179         if (call_streambuf_sync(&this->base) == EOF)
1180             return EOF;
1181         buffer_size = this->base.ebuf - this->base.base;
1182         read_bytes = _read(this->fd, this->base.base, buffer_size);
1183         if (read_bytes <= 0)
1184             return EOF;
1185         this->base.eback = this->base.gptr = this->base.base;
1186         this->base.egptr = this->base.base + read_bytes;
1187     }
1188     return (unsigned char) *this->base.gptr;
1189 }
1190
1191 /* ??0strstreambuf@@QAE@ABV0@@Z */
1192 /* ??0strstreambuf@@QEAA@AEBV0@@Z */
1193 DEFINE_THISCALL_WRAPPER(strstreambuf_copy_ctor, 8)
1194 strstreambuf* __thiscall strstreambuf_copy_ctor(strstreambuf *this, const strstreambuf *copy)
1195 {
1196     TRACE("(%p %p)\n", this, copy);
1197     *this = *copy;
1198     this->base.vtable = &MSVCP_strstreambuf_vtable;
1199     return this;
1200 }
1201
1202 /* ??0strstreambuf@@QAE@H@Z */
1203 /* ??0strstreambuf@@QEAA@H@Z */
1204 DEFINE_THISCALL_WRAPPER(strstreambuf_dynamic_ctor, 8)
1205 strstreambuf* __thiscall strstreambuf_dynamic_ctor(strstreambuf* this, int length)
1206 {
1207     TRACE("(%p %d)\n", this, length);
1208     streambuf_ctor(&this->base);
1209     this->base.vtable = &MSVCP_strstreambuf_vtable;
1210     this->dynamic = 1;
1211     this->increase = length;
1212     this->constant = 0;
1213     this->f_alloc = NULL;
1214     this->f_free = NULL;
1215     return this;
1216 }
1217
1218 /* ??0strstreambuf@@QAE@P6APAXJ@ZP6AXPAX@Z@Z */
1219 /* ??0strstreambuf@@QEAA@P6APEAXJ@ZP6AXPEAX@Z@Z */
1220 DEFINE_THISCALL_WRAPPER(strstreambuf_funcs_ctor, 12)
1221 strstreambuf* __thiscall strstreambuf_funcs_ctor(strstreambuf* this, allocFunction falloc, freeFunction ffree)
1222 {
1223     TRACE("(%p %p %p)\n", this, falloc, ffree);
1224     strstreambuf_dynamic_ctor(this, 1);
1225     this->f_alloc = falloc;
1226     this->f_free = ffree;
1227     return this;
1228 }
1229
1230 /* ??0strstreambuf@@QAE@PADH0@Z */
1231 /* ??0strstreambuf@@QEAA@PEADH0@Z */
1232 DEFINE_THISCALL_WRAPPER(strstreambuf_buffer_ctor, 16)
1233 strstreambuf* __thiscall strstreambuf_buffer_ctor(strstreambuf *this, char *buffer, int length, char *put)
1234 {
1235     char *end_buffer;
1236
1237     TRACE("(%p %p %d %p)\n", this, buffer, length, put);
1238
1239     if (length > 0)
1240         end_buffer = buffer + length;
1241     else if (length == 0)
1242         end_buffer = buffer + strlen(buffer);
1243     else
1244         end_buffer = (char*) -1;
1245
1246     streambuf_ctor(&this->base);
1247     streambuf_setb(&this->base, buffer, end_buffer, 0);
1248     if (put == NULL) {
1249         streambuf_setg(&this->base, buffer, buffer, end_buffer);
1250     } else {
1251         streambuf_setg(&this->base, buffer, buffer, put);
1252         streambuf_setp(&this->base, put, end_buffer);
1253     }
1254     this->base.vtable = &MSVCP_strstreambuf_vtable;
1255     this->dynamic = 0;
1256     this->constant = 1;
1257     return this;
1258 }
1259
1260 /* ??0strstreambuf@@QAE@PAEH0@Z */
1261 /* ??0strstreambuf@@QEAA@PEAEH0@Z */
1262 DEFINE_THISCALL_WRAPPER(strstreambuf_ubuffer_ctor, 16)
1263 strstreambuf* __thiscall strstreambuf_ubuffer_ctor(strstreambuf *this, unsigned char *buffer, int length, unsigned char *put)
1264 {
1265     TRACE("(%p %p %d %p)\n", this, buffer, length, put);
1266     return strstreambuf_buffer_ctor(this, (char*)buffer, length, (char*)put);
1267 }
1268
1269 /* ??0strstreambuf@@QAE@XZ */
1270 /* ??0strstreambuf@@QEAA@XZ */
1271 DEFINE_THISCALL_WRAPPER(strstreambuf_ctor, 4)
1272 strstreambuf* __thiscall strstreambuf_ctor(strstreambuf *this)
1273 {
1274     TRACE("(%p)\n", this);
1275     return strstreambuf_dynamic_ctor(this, 1);
1276 }
1277
1278 /* ??1strstreambuf@@UAE@XZ */
1279 /* ??1strstreambuf@@UEAA@XZ */
1280 DEFINE_THISCALL_WRAPPER(strstreambuf_dtor, 4)
1281 void __thiscall strstreambuf_dtor(strstreambuf *this)
1282 {
1283     TRACE("(%p)\n", this);
1284     if (this->dynamic && this->base.base) {
1285         if (this->f_free)
1286             this->f_free(this->base.base);
1287         else
1288             MSVCRT_operator_delete(this->base.base);
1289     }
1290     streambuf_dtor(&this->base);
1291 }
1292
1293 /* ??4strstreambuf@@QAEAAV0@ABV0@@Z */
1294 /* ??4strstreambuf@@QEAAAEAV0@AEBV0@@Z */
1295 DEFINE_THISCALL_WRAPPER(strstreambuf_assign, 8)
1296 strstreambuf* __thiscall strstreambuf_assign(strstreambuf *this, const strstreambuf *rhs)
1297 {
1298     strstreambuf_dtor(this);
1299     return strstreambuf_copy_ctor(this, rhs);
1300 }
1301
1302 /* ??_Estrstreambuf@@UAEPAXI@Z */
1303 DEFINE_THISCALL_WRAPPER(strstreambuf_vector_dtor, 8)
1304 strstreambuf* __thiscall strstreambuf_vector_dtor(strstreambuf *this, unsigned int flags)
1305 {
1306     TRACE("(%p %x)\n", this, flags);
1307     if (flags & 2) {
1308         /* we have an array, with the number of elements stored before the first object */
1309         INT_PTR i, *ptr = (INT_PTR *)this-1;
1310
1311         for (i = *ptr-1; i >= 0; i--)
1312             strstreambuf_dtor(this+i);
1313         MSVCRT_operator_delete(ptr);
1314     } else {
1315         strstreambuf_dtor(this);
1316         if (flags & 1)
1317             MSVCRT_operator_delete(this);
1318     }
1319     return this;
1320 }
1321
1322 /* ??_Gstrstreambuf@@UAEPAXI@Z */
1323 DEFINE_THISCALL_WRAPPER(strstreambuf_scalar_dtor, 8)
1324 strstreambuf* __thiscall strstreambuf_scalar_dtor(strstreambuf *this, unsigned int flags)
1325 {
1326     TRACE("(%p %x)\n", this, flags);
1327     strstreambuf_dtor(this);
1328     if (flags & 1) MSVCRT_operator_delete(this);
1329     return this;
1330 }
1331
1332 /* ?doallocate@strstreambuf@@MAEHXZ */
1333 /* ?doallocate@strstreambuf@@MEAAHXZ */
1334 DEFINE_THISCALL_WRAPPER(strstreambuf_doallocate, 4)
1335 int __thiscall strstreambuf_doallocate(strstreambuf *this)
1336 {
1337     char *prev_buffer = this->base.base, *new_buffer;
1338     LONG prev_size = this->base.ebuf - this->base.base, new_size;
1339
1340     TRACE("(%p)\n", this);
1341
1342     /* calculate the size of the new buffer */
1343     new_size = (prev_size > 0 ? prev_size : 0) + (this->increase > 0 ? this->increase : 1);
1344     /* get a new buffer */
1345     if (this->f_alloc)
1346         new_buffer = this->f_alloc(new_size);
1347     else
1348         new_buffer = MSVCRT_operator_new(new_size);
1349     if (!new_buffer)
1350         return EOF;
1351     if (this->base.ebuf) {
1352         /* copy the contents and adjust the pointers */
1353         memcpy(new_buffer, this->base.base, prev_size);
1354         if (this->base.egptr) {
1355             this->base.eback += new_buffer - prev_buffer;
1356             this->base.gptr += new_buffer - prev_buffer;
1357             this->base.egptr += new_buffer - prev_buffer;
1358         }
1359         if (this->base.epptr) {
1360             this->base.pbase += new_buffer - prev_buffer;
1361             this->base.pptr += new_buffer - prev_buffer;
1362             this->base.epptr += new_buffer - prev_buffer;
1363         }
1364         /* free the old buffer */
1365         if (this->f_free)
1366             this->f_free(this->base.base);
1367         else
1368             MSVCRT_operator_delete(this->base.base);
1369     }
1370     streambuf_setb(&this->base, new_buffer, new_buffer + new_size, 0);
1371     return 1;
1372 }
1373
1374 /* ?freeze@strstreambuf@@QAEXH@Z */
1375 /* ?freeze@strstreambuf@@QEAAXH@Z */
1376 DEFINE_THISCALL_WRAPPER(strstreambuf_freeze, 8)
1377 void __thiscall strstreambuf_freeze(strstreambuf *this, int frozen)
1378 {
1379     TRACE("(%p %d)\n", this, frozen);
1380     if (!this->constant)
1381         this->dynamic = !frozen;
1382 }
1383
1384 /* ?overflow@strstreambuf@@UAEHH@Z */
1385 /* ?overflow@strstreambuf@@UEAAHH@Z */
1386 DEFINE_THISCALL_WRAPPER(strstreambuf_overflow, 8)
1387 int __thiscall strstreambuf_overflow(strstreambuf *this, int c)
1388 {
1389     TRACE("(%p %d)\n", this, c);
1390     if (this->base.pptr >= this->base.epptr) {
1391         /* increase the buffer size if it's dynamic */
1392         if (!this->dynamic || call_streambuf_doallocate(&this->base) == EOF)
1393             return EOF;
1394         if (!this->base.epptr)
1395             this->base.pbase = this->base.pptr = this->base.egptr ? this->base.egptr : this->base.base;
1396         this->base.epptr = this->base.ebuf;
1397     }
1398     if (c != EOF)
1399         *this->base.pptr++ = c;
1400     return 1;
1401 }
1402
1403 /* ?seekoff@strstreambuf@@UAEJJW4seek_dir@ios@@H@Z */
1404 /* ?seekoff@strstreambuf@@UEAAJJW4seek_dir@ios@@H@Z */
1405 DEFINE_THISCALL_WRAPPER(strstreambuf_seekoff, 16)
1406 streampos __thiscall strstreambuf_seekoff(strstreambuf *this, streamoff offset, ios_seek_dir dir, int mode)
1407 {
1408     char *base[3];
1409
1410     TRACE("(%p %d %d %d)\n", this, offset, dir, mode);
1411
1412     if ((unsigned int)dir > SEEKDIR_end || !(mode & (OPENMODE_in|OPENMODE_out)))
1413         return EOF;
1414     /* read buffer */
1415     if (mode & OPENMODE_in) {
1416         call_streambuf_underflow(&this->base);
1417         base[SEEKDIR_beg] = this->base.eback;
1418         base[SEEKDIR_cur] = this->base.gptr;
1419         base[SEEKDIR_end] = this->base.egptr;
1420         if (base[dir] + offset < this->base.eback || base[dir] + offset > this->base.egptr)
1421             return EOF;
1422         this->base.gptr = base[dir] + offset;
1423     }
1424     /* write buffer */
1425     if (mode & OPENMODE_out) {
1426         if (!this->base.epptr && call_streambuf_overflow(&this->base, EOF) == EOF)
1427             return EOF;
1428         base[SEEKDIR_beg] = this->base.pbase;
1429         base[SEEKDIR_cur] = this->base.pptr;
1430         base[SEEKDIR_end] = this->base.epptr;
1431         if (base[dir] + offset < this->base.pbase)
1432             return EOF;
1433         if (base[dir] + offset > this->base.epptr) {
1434             /* make room if the buffer is dynamic */
1435             if (!this->dynamic)
1436                 return EOF;
1437             this->increase = offset;
1438             if (call_streambuf_doallocate(&this->base) == EOF)
1439                 return EOF;
1440         }
1441         this->base.pptr = base[dir] + offset;
1442         return this->base.pptr - base[SEEKDIR_beg];
1443     }
1444     return this->base.gptr - base[SEEKDIR_beg];
1445 }
1446
1447 /* ?setbuf@strstreambuf@@UAEPAVstreambuf@@PADH@Z */
1448 /* ?setbuf@strstreambuf@@UEAAPEAVstreambuf@@PEADH@Z */
1449 DEFINE_THISCALL_WRAPPER(strstreambuf_setbuf, 12)
1450 streambuf* __thiscall strstreambuf_setbuf(strstreambuf *this, char *buffer, int length)
1451 {
1452     TRACE("(%p %p %d)\n", this, buffer, length);
1453     if (length)
1454         this->increase = length;
1455     return &this->base;
1456 }
1457
1458 /* ?str@strstreambuf@@QAEPADXZ */
1459 /* ?str@strstreambuf@@QEAAPEADXZ */
1460 DEFINE_THISCALL_WRAPPER(strstreambuf_str, 4)
1461 char* __thiscall strstreambuf_str(strstreambuf *this)
1462 {
1463     TRACE("(%p)\n", this);
1464     strstreambuf_freeze(this, 1);
1465     return this->base.base;
1466 }
1467
1468 /* ?sync@strstreambuf@@UAEHXZ */
1469 /* ?sync@strstreambuf@@UEAAHXZ */
1470 DEFINE_THISCALL_WRAPPER(strstreambuf_sync, 4)
1471 int __thiscall strstreambuf_sync(strstreambuf *this)
1472 {
1473     TRACE("(%p)\n", this);
1474     return 0;
1475 }
1476
1477 /* ?underflow@strstreambuf@@UAEHXZ */
1478 /* ?underflow@strstreambuf@@UEAAHXZ */
1479 DEFINE_THISCALL_WRAPPER(strstreambuf_underflow, 4)
1480 int __thiscall strstreambuf_underflow(strstreambuf *this)
1481 {
1482     TRACE("(%p)\n", this);
1483     if (this->base.gptr < this->base.egptr)
1484         return (unsigned char) *this->base.gptr;
1485     /* extend the get area to include the characters written */
1486     if (this->base.egptr < this->base.pptr) {
1487         this->base.gptr = this->base.base + (this->base.gptr - this->base.eback);
1488         this->base.eback = this->base.base;
1489         this->base.egptr = this->base.pptr;
1490     }
1491     return (this->base.gptr < this->base.egptr) ? (unsigned char)(*this->base.gptr) : EOF;
1492 }
1493
1494 /* ??0stdiobuf@@QAE@ABV0@@Z */
1495 /* ??0stdiobuf@@QEAA@AEBV0@@Z */
1496 DEFINE_THISCALL_WRAPPER(stdiobuf_copy_ctor, 8)
1497 stdiobuf* __thiscall stdiobuf_copy_ctor(stdiobuf *this, const stdiobuf *copy)
1498 {
1499     TRACE("(%p %p)\n", this, copy);
1500     *this = *copy;
1501     this->base.vtable = &MSVCP_stdiobuf_vtable;
1502     return this;
1503 }
1504
1505 /* ??0stdiobuf@@QAE@PAU_iobuf@@@Z */
1506 /* ??0stdiobuf@@QEAA@PEAU_iobuf@@@Z */
1507 DEFINE_THISCALL_WRAPPER(stdiobuf_file_ctor, 8)
1508 stdiobuf* __thiscall stdiobuf_file_ctor(stdiobuf *this, FILE *file)
1509 {
1510     TRACE("(%p %p)\n", this, file);
1511     streambuf_reserve_ctor(&this->base, NULL, 0);
1512     this->base.vtable = &MSVCP_stdiobuf_vtable;
1513     this->file = file;
1514     return this;
1515 }
1516
1517 /* ??1stdiobuf@@UAE@XZ */
1518 /* ??1stdiobuf@@UEAA@XZ */
1519 DEFINE_THISCALL_WRAPPER(stdiobuf_dtor, 4)
1520 void __thiscall stdiobuf_dtor(stdiobuf *this)
1521 {
1522     TRACE("(%p)\n", this);
1523     call_streambuf_sync(&this->base);
1524     streambuf_dtor(&this->base);
1525 }
1526
1527 /* ??4stdiobuf@@QAEAAV0@ABV0@@Z */
1528 /* ??4stdiobuf@@QEAAAEAV0@AEBV0@@Z */
1529 DEFINE_THISCALL_WRAPPER(stdiobuf_assign, 8)
1530 stdiobuf* __thiscall stdiobuf_assign(stdiobuf *this, const stdiobuf *rhs)
1531 {
1532     stdiobuf_dtor(this);
1533     return stdiobuf_copy_ctor(this, rhs);
1534 }
1535
1536 /* ??_Estdiobuf@@UAEPAXI@Z */
1537 DEFINE_THISCALL_WRAPPER(stdiobuf_vector_dtor, 8)
1538 stdiobuf* __thiscall stdiobuf_vector_dtor(stdiobuf *this, unsigned int flags)
1539 {
1540     TRACE("(%p %x)\n", this, flags);
1541     if (flags & 2) {
1542         /* we have an array, with the number of elements stored before the first object */
1543         INT_PTR i, *ptr = (INT_PTR *)this-1;
1544
1545         for (i = *ptr-1; i >= 0; i--)
1546             stdiobuf_dtor(this+i);
1547         MSVCRT_operator_delete(ptr);
1548     } else {
1549         stdiobuf_dtor(this);
1550         if (flags & 1)
1551             MSVCRT_operator_delete(this);
1552     }
1553     return this;
1554 }
1555
1556 /* ??_Gstdiobuf@@UAEPAXI@Z */
1557 DEFINE_THISCALL_WRAPPER(stdiobuf_scalar_dtor, 8)
1558 stdiobuf* __thiscall stdiobuf_scalar_dtor(stdiobuf *this, unsigned int flags)
1559 {
1560     TRACE("(%p %x)\n", this, flags);
1561     stdiobuf_dtor(this);
1562     if (flags & 1) MSVCRT_operator_delete(this);
1563     return this;
1564 }
1565
1566 /* ?overflow@stdiobuf@@UAEHH@Z */
1567 /* ?overflow@stdiobuf@@UEAAHH@Z */
1568 DEFINE_THISCALL_WRAPPER(stdiobuf_overflow, 8)
1569 int __thiscall stdiobuf_overflow(stdiobuf *this, int c)
1570 {
1571     TRACE("(%p %d)\n", this, c);
1572     if (this->base.unbuffered)
1573         return (c == EOF) ? 1 : fputc(c, this->file);
1574     if (streambuf_allocate(&this->base) == EOF)
1575         return EOF;
1576
1577     if (!this->base.epptr) {
1578         /* set the put area to the second half of the buffer */
1579         streambuf_setp(&this->base,
1580             this->base.base + (this->base.ebuf - this->base.base) / 2, this->base.ebuf);
1581     } else if (this->base.pptr > this->base.pbase) {
1582         /* flush the put area */
1583         int count = this->base.pptr - this->base.pbase;
1584         if (fwrite(this->base.pbase, sizeof(char), count, this->file) != count)
1585             return EOF;
1586         this->base.pptr = this->base.pbase;
1587     }
1588     if (c != EOF) {
1589         if (this->base.pbase >= this->base.epptr)
1590             return fputc(c, this->file);
1591         *this->base.pptr++ = c;
1592     }
1593     return 1;
1594 }
1595
1596 /* ?pbackfail@stdiobuf@@UAEHH@Z */
1597 /* ?pbackfail@stdiobuf@@UEAAHH@Z */
1598 DEFINE_THISCALL_WRAPPER(stdiobuf_pbackfail, 8)
1599 int __thiscall stdiobuf_pbackfail(stdiobuf *this, int c)
1600 {
1601     TRACE("(%p %d)\n", this, c);
1602     return streambuf_pbackfail(&this->base, c);
1603 }
1604
1605 /* ?seekoff@stdiobuf@@UAEJJW4seek_dir@ios@@H@Z */
1606 /* ?seekoff@stdiobuf@@UEAAJJW4seek_dir@ios@@H@Z */
1607 DEFINE_THISCALL_WRAPPER(stdiobuf_seekoff, 16)
1608 streampos __thiscall stdiobuf_seekoff(stdiobuf *this, streamoff offset, ios_seek_dir dir, int mode)
1609 {
1610     TRACE("(%p %d %d %d)\n", this, offset, dir, mode);
1611     call_streambuf_overflow(&this->base, EOF);
1612     if (fseek(this->file, offset, dir))
1613         return EOF;
1614     return ftell(this->file);
1615 }
1616
1617 /* ?setrwbuf@stdiobuf@@QAEHHH@Z */
1618 /* ?setrwbuf@stdiobuf@@QEAAHHH@Z */
1619 DEFINE_THISCALL_WRAPPER(stdiobuf_setrwbuf, 12)
1620 int __thiscall stdiobuf_setrwbuf(stdiobuf *this, int read_size, int write_size)
1621 {
1622     char *reserve;
1623     int buffer_size = read_size + write_size;
1624
1625     TRACE("(%p %d %d)\n", this, read_size, write_size);
1626     if (read_size < 0 || write_size < 0)
1627         return 0;
1628     if (!buffer_size) {
1629         this->base.unbuffered = 1;
1630         return 0;
1631     }
1632     /* get a new buffer */
1633     reserve = MSVCRT_operator_new(buffer_size);
1634     if (!reserve)
1635         return 0;
1636     streambuf_setb(&this->base, reserve, reserve + buffer_size, 1);
1637     this->base.unbuffered = 0;
1638     /* set the get/put areas */
1639     if (read_size > 0)
1640         streambuf_setg(&this->base, reserve, reserve + read_size, reserve + read_size);
1641     else
1642         streambuf_setg(&this->base, NULL, NULL, NULL);
1643     if (write_size > 0)
1644         streambuf_setp(&this->base, reserve + read_size, reserve + buffer_size);
1645     else
1646         streambuf_setp(&this->base, NULL, NULL);
1647     return 1;
1648 }
1649
1650 /* ?stdiofile@stdiobuf@@QAEPAU_iobuf@@XZ */
1651 /* ?stdiofile@stdiobuf@@QEAAPEAU_iobuf@@XZ */
1652 DEFINE_THISCALL_WRAPPER(stdiobuf_stdiofile, 4)
1653 FILE* __thiscall stdiobuf_stdiofile(stdiobuf *this)
1654 {
1655     TRACE("(%p)\n", this);
1656     return this->file;
1657 }
1658
1659 /* ?sync@stdiobuf@@UAEHXZ */
1660 /* ?sync@stdiobuf@@UEAAHXZ */
1661 DEFINE_THISCALL_WRAPPER(stdiobuf_sync, 4)
1662 int __thiscall stdiobuf_sync(stdiobuf *this)
1663 {
1664     TRACE("(%p)\n", this);
1665     if (this->base.unbuffered)
1666         return 0;
1667     /* flush the put area */
1668     if (call_streambuf_overflow(&this->base, EOF) == EOF)
1669         return EOF;
1670     /* flush the get area */
1671     if (this->base.gptr < this->base.egptr) {
1672         char *ptr;
1673         int fd, mode, offset = this->base.egptr - this->base.gptr;
1674         if ((fd = fileno(this->file)) < 0)
1675             return EOF;
1676         mode = _setmode(fd, _O_TEXT);
1677         _setmode(fd, mode);
1678         if (mode & _O_TEXT) {
1679             /* in text mode, '\n' in the buffer means '\r\n' in the file */
1680             for (ptr = this->base.gptr; ptr < this->base.egptr; ptr++)
1681                 if (*ptr == '\n')
1682                     offset++;
1683         }
1684         if (fseek(this->file, -offset, SEEK_CUR))
1685             return EOF;
1686         this->base.gptr = this->base.egptr;
1687     }
1688     return 0;
1689 }
1690
1691 /* ?underflow@stdiobuf@@UAEHXZ */
1692 /* ?underflow@stdiobuf@@UEAAHXZ */
1693 DEFINE_THISCALL_WRAPPER(stdiobuf_underflow, 4)
1694 int __thiscall stdiobuf_underflow(stdiobuf *this)
1695 {
1696     TRACE("(%p)\n", this);
1697     if (!this->file)
1698         return EOF;
1699     if (this->base.unbuffered)
1700         return fgetc(this->file);
1701     if (streambuf_allocate(&this->base) == EOF)
1702         return EOF;
1703
1704     if (!this->base.egptr) {
1705         /* set the get area to the first half of the buffer */
1706         char *middle = this->base.base + (this->base.ebuf - this->base.base) / 2;
1707         streambuf_setg(&this->base, this->base.base, middle, middle);
1708     }
1709     if (this->base.gptr >= this->base.egptr) {
1710         /* read characters from the file */
1711         int buffer_size = this->base.egptr - this->base.eback, read_bytes;
1712         if (!this->base.eback ||
1713             (read_bytes = fread(this->base.eback, sizeof(char), buffer_size, this->file)) <= 0)
1714             return EOF;
1715         memmove(this->base.egptr - read_bytes, this->base.eback, read_bytes);
1716         this->base.gptr = this->base.egptr - read_bytes;
1717     }
1718     return (unsigned char) *this->base.gptr++;
1719 }
1720
1721 /* ??0ios@@IAE@ABV0@@Z */
1722 /* ??0ios@@IEAA@AEBV0@@Z */
1723 DEFINE_THISCALL_WRAPPER(ios_copy_ctor, 8)
1724 ios* __thiscall ios_copy_ctor(ios *this, const ios *copy)
1725 {
1726     TRACE("(%p %p)\n", this, copy);
1727     ios_fLockcInit++;
1728     this->vtable = &MSVCP_ios_vtable;
1729     this->sb = NULL;
1730     this->delbuf = 0;
1731     InitializeCriticalSection(&this->lock);
1732     return ios_assign(this, copy);
1733 }
1734
1735 /* ??0ios@@QAE@PAVstreambuf@@@Z */
1736 /* ??0ios@@QEAA@PEAVstreambuf@@@Z */
1737 DEFINE_THISCALL_WRAPPER(ios_sb_ctor, 8)
1738 ios* __thiscall ios_sb_ctor(ios *this, streambuf *sb)
1739 {
1740     TRACE("(%p %p)\n", this, sb);
1741     ios_fLockcInit++;
1742     this->vtable = &MSVCP_ios_vtable;
1743     this->sb = sb;
1744     this->state = sb ? IOSTATE_goodbit : IOSTATE_badbit;
1745     this->special[0] = this->special[1] = 0;
1746     this->delbuf = 0;
1747     this->tie = NULL;
1748     this->flags = 0;
1749     this->precision = 6;
1750     this->fill = ' ';
1751     this->width = 0;
1752     this->do_lock = -1;
1753     InitializeCriticalSection(&this->lock);
1754     return this;
1755 }
1756
1757 /* ??0ios@@IAE@XZ */
1758 /* ??0ios@@IEAA@XZ */
1759 DEFINE_THISCALL_WRAPPER(ios_ctor, 4)
1760 ios* __thiscall ios_ctor(ios *this)
1761 {
1762     return ios_sb_ctor(this, NULL);
1763 }
1764
1765 /* ??1ios@@UAE@XZ */
1766 /* ??1ios@@UEAA@XZ */
1767 DEFINE_THISCALL_WRAPPER(ios_dtor, 4)
1768 void __thiscall ios_dtor(ios *this)
1769 {
1770     TRACE("(%p)\n", this);
1771     ios_fLockcInit--;
1772     if (this->delbuf && this->sb)
1773         call_streambuf_vector_dtor(this->sb, 1);
1774     this->sb = NULL;
1775     this->state = IOSTATE_badbit;
1776     DeleteCriticalSection(&this->lock);
1777 }
1778
1779 /* ??4ios@@IAEAAV0@ABV0@@Z */
1780 /* ??4ios@@IEAAAEAV0@AEBV0@@Z */
1781 DEFINE_THISCALL_WRAPPER(ios_assign, 8)
1782 ios* __thiscall ios_assign(ios *this, const ios *rhs)
1783 {
1784     TRACE("(%p %p)\n", this, rhs);
1785     this->state = rhs->state;
1786     if (!this->sb)
1787         this->state |= IOSTATE_badbit;
1788     this->tie = rhs->tie;
1789     this->flags = rhs->flags;
1790     this->precision = (char) rhs->precision;
1791     this->fill = rhs->fill;
1792     this->width = (char) rhs->width;
1793     return this;
1794 }
1795
1796 /* ??7ios@@QBEHXZ */
1797 /* ??7ios@@QEBAHXZ */
1798 DEFINE_THISCALL_WRAPPER(ios_op_not, 4)
1799 int __thiscall ios_op_not(const ios *this)
1800 {
1801     TRACE("(%p)\n", this);
1802     return ios_fail(this);
1803 }
1804
1805 /* ??Bios@@QBEPAXXZ */
1806 /* ??Bios@@QEBAPEAXXZ */
1807 DEFINE_THISCALL_WRAPPER(ios_op_void, 4)
1808 void* __thiscall ios_op_void(const ios *this)
1809 {
1810     TRACE("(%p)\n", this);
1811     return ios_fail(this) ? NULL : (void*)this;
1812 }
1813
1814 /* ??_Eios@@UAEPAXI@Z */
1815 DEFINE_THISCALL_WRAPPER(ios_vector_dtor, 8)
1816 ios* __thiscall ios_vector_dtor(ios *this, unsigned int flags)
1817 {
1818     TRACE("(%p %x)\n", this, flags);
1819     if (flags & 2) {
1820         /* we have an array, with the number of elements stored before the first object */
1821         INT_PTR i, *ptr = (INT_PTR *)this-1;
1822
1823         for (i = *ptr-1; i >= 0; i--)
1824             ios_dtor(this+i);
1825         MSVCRT_operator_delete(ptr);
1826     } else {
1827         ios_dtor(this);
1828         if (flags & 1)
1829             MSVCRT_operator_delete(this);
1830     }
1831     return this;
1832 }
1833
1834 /* ??_Gios@@UAEPAXI@Z */
1835 DEFINE_THISCALL_WRAPPER(ios_scalar_dtor, 8)
1836 ios* __thiscall ios_scalar_dtor(ios *this, unsigned int flags)
1837 {
1838     TRACE("(%p %x)\n", this, flags);
1839     ios_dtor(this);
1840     if (flags & 1) MSVCRT_operator_delete(this);
1841     return this;
1842 }
1843
1844 /* ?bad@ios@@QBEHXZ */
1845 /* ?bad@ios@@QEBAHXZ */
1846 DEFINE_THISCALL_WRAPPER(ios_bad, 4)
1847 int __thiscall ios_bad(const ios *this)
1848 {
1849     TRACE("(%p)\n", this);
1850     return (this->state & IOSTATE_badbit);
1851 }
1852
1853 /* ?bitalloc@ios@@SAJXZ */
1854 LONG __cdecl ios_bitalloc(void)
1855 {
1856     TRACE("()\n");
1857     ios_lockc();
1858     ios_maxbit <<= 1;
1859     ios_unlockc();
1860     return ios_maxbit;
1861 }
1862
1863 /* ?clear@ios@@QAEXH@Z */
1864 /* ?clear@ios@@QEAAXH@Z */
1865 DEFINE_THISCALL_WRAPPER(ios_clear, 8)
1866 void __thiscall ios_clear(ios *this, int state)
1867 {
1868     TRACE("(%p %d)\n", this, state);
1869     ios_lock(this);
1870     this->state = state;
1871     ios_unlock(this);
1872 }
1873
1874 /* ?clrlock@ios@@QAAXXZ */
1875 /* ?clrlock@ios@@QEAAXXZ */
1876 void __cdecl ios_clrlock(ios *this)
1877 {
1878     TRACE("(%p)\n", this);
1879     if (this->do_lock <= 0)
1880         this->do_lock++;
1881     if (this->sb)
1882         streambuf_clrlock(this->sb);
1883 }
1884
1885 /* ?delbuf@ios@@QAEXH@Z */
1886 /* ?delbuf@ios@@QEAAXH@Z */
1887 DEFINE_THISCALL_WRAPPER(ios_delbuf_set, 8)
1888 void __thiscall ios_delbuf_set(ios *this, int delete)
1889 {
1890     TRACE("(%p %d)\n", this, delete);
1891     this->delbuf = delete;
1892 }
1893
1894 /* ?delbuf@ios@@QBEHXZ */
1895 /* ?delbuf@ios@@QEBAHXZ */
1896 DEFINE_THISCALL_WRAPPER(ios_delbuf_get, 4)
1897 int __thiscall ios_delbuf_get(const ios *this)
1898 {
1899     TRACE("(%p)\n", this);
1900     return this->delbuf;
1901 }
1902
1903 /* ?dec@@YAAAVios@@AAV1@@Z */
1904 /* ?dec@@YAAEAVios@@AEAV1@@Z */
1905 ios* __cdecl ios_dec(ios *this)
1906 {
1907     TRACE("(%p)\n", this);
1908     ios_setf_mask(this, FLAGS_dec, ios_basefield);
1909     return this;
1910 }
1911
1912 /* ?eof@ios@@QBEHXZ */
1913 /* ?eof@ios@@QEBAHXZ */
1914 DEFINE_THISCALL_WRAPPER(ios_eof, 4)
1915 int __thiscall ios_eof(const ios *this)
1916 {
1917     TRACE("(%p)\n", this);
1918     return (this->state & IOSTATE_eofbit);
1919 }
1920
1921 /* ?fail@ios@@QBEHXZ */
1922 /* ?fail@ios@@QEBAHXZ */
1923 DEFINE_THISCALL_WRAPPER(ios_fail, 4)
1924 int __thiscall ios_fail(const ios *this)
1925 {
1926     TRACE("(%p)\n", this);
1927     return (this->state & (IOSTATE_failbit|IOSTATE_badbit));
1928 }
1929
1930 /* ?fill@ios@@QAEDD@Z */
1931 /* ?fill@ios@@QEAADD@Z */
1932 DEFINE_THISCALL_WRAPPER(ios_fill_set, 8)
1933 char __thiscall ios_fill_set(ios *this, char fill)
1934 {
1935     char prev = this->fill;
1936
1937     TRACE("(%p %d)\n", this, fill);
1938
1939     this->fill = fill;
1940     return prev;
1941 }
1942
1943 /* ?fill@ios@@QBEDXZ */
1944 /* ?fill@ios@@QEBADXZ */
1945 DEFINE_THISCALL_WRAPPER(ios_fill_get, 4)
1946 char __thiscall ios_fill_get(const ios *this)
1947 {
1948     TRACE("(%p)\n", this);
1949     return this->fill;
1950 }
1951
1952 /* ?flags@ios@@QAEJJ@Z */
1953 /* ?flags@ios@@QEAAJJ@Z */
1954 DEFINE_THISCALL_WRAPPER(ios_flags_set, 8)
1955 LONG __thiscall ios_flags_set(ios *this, LONG flags)
1956 {
1957     LONG prev = this->flags;
1958
1959     TRACE("(%p %x)\n", this, flags);
1960
1961     this->flags = flags;
1962     return prev;
1963 }
1964
1965 /* ?flags@ios@@QBEJXZ */
1966 /* ?flags@ios@@QEBAJXZ */
1967 DEFINE_THISCALL_WRAPPER(ios_flags_get, 4)
1968 LONG __thiscall ios_flags_get(const ios *this)
1969 {
1970     TRACE("(%p)\n", this);
1971     return this->flags;
1972 }
1973
1974 /* ?good@ios@@QBEHXZ */
1975 /* ?good@ios@@QEBAHXZ */
1976 DEFINE_THISCALL_WRAPPER(ios_good, 4)
1977 int __thiscall ios_good(const ios *this)
1978 {
1979     TRACE("(%p)\n", this);
1980     return this->state == IOSTATE_goodbit;
1981 }
1982
1983 /* ?hex@@YAAAVios@@AAV1@@Z */
1984 /* ?hex@@YAAEAVios@@AEAV1@@Z */
1985 ios* __cdecl ios_hex(ios *this)
1986 {
1987     TRACE("(%p)\n", this);
1988     ios_setf_mask(this, FLAGS_hex, ios_basefield);
1989     return this;
1990 }
1991
1992 /* ?init@ios@@IAEXPAVstreambuf@@@Z */
1993 /* ?init@ios@@IEAAXPEAVstreambuf@@@Z */
1994 DEFINE_THISCALL_WRAPPER(ios_init, 8)
1995 void __thiscall ios_init(ios *this, streambuf *sb)
1996 {
1997     TRACE("(%p %p)\n", this, sb);
1998     if (this->delbuf && this->sb)
1999         call_streambuf_vector_dtor(this->sb, 1);
2000     this->sb = sb;
2001     if (sb == NULL)
2002         this->state |= IOSTATE_badbit;
2003     else
2004         this->state &= ~IOSTATE_badbit;
2005 }
2006
2007 /* ?iword@ios@@QBEAAJH@Z */
2008 /* ?iword@ios@@QEBAAEAJH@Z */
2009 DEFINE_THISCALL_WRAPPER(ios_iword, 8)
2010 LONG* __thiscall ios_iword(const ios *this, int index)
2011 {
2012     TRACE("(%p %d)\n", this, index);
2013     return &ios_statebuf[index];
2014 }
2015
2016 /* ?lock@ios@@QAAXXZ */
2017 /* ?lock@ios@@QEAAXXZ */
2018 void __cdecl ios_lock(ios *this)
2019 {
2020     TRACE("(%p)\n", this);
2021     if (this->do_lock < 0)
2022         EnterCriticalSection(&this->lock);
2023 }
2024
2025 /* ?lockbuf@ios@@QAAXXZ */
2026 /* ?lockbuf@ios@@QEAAXXZ */
2027 void __cdecl ios_lockbuf(ios *this)
2028 {
2029     TRACE("(%p)\n", this);
2030     streambuf_lock(this->sb);
2031 }
2032
2033 /* ?lockc@ios@@KAXXZ */
2034 void __cdecl ios_lockc(void)
2035 {
2036     TRACE("()\n");
2037     EnterCriticalSection(&ios_static_lock);
2038 }
2039
2040 /* ?lockptr@ios@@IAEPAU_CRT_CRITICAL_SECTION@@XZ */
2041 /* ?lockptr@ios@@IEAAPEAU_CRT_CRITICAL_SECTION@@XZ */
2042 DEFINE_THISCALL_WRAPPER(ios_lockptr, 4)
2043 CRITICAL_SECTION* __thiscall ios_lockptr(ios *this)
2044 {
2045     TRACE("(%p)\n", this);
2046     return &this->lock;
2047 }
2048
2049 /* ?oct@@YAAAVios@@AAV1@@Z */
2050 /* ?oct@@YAAEAVios@@AEAV1@@Z */
2051 ios* __cdecl ios_oct(ios *this)
2052 {
2053     TRACE("(%p)\n", this);
2054     ios_setf_mask(this, FLAGS_oct, ios_basefield);
2055     return this;
2056 }
2057
2058 /* ?precision@ios@@QAEHH@Z */
2059 /* ?precision@ios@@QEAAHH@Z */
2060 DEFINE_THISCALL_WRAPPER(ios_precision_set, 8)
2061 int __thiscall ios_precision_set(ios *this, int prec)
2062 {
2063     int prev = this->precision;
2064
2065     TRACE("(%p %d)\n", this, prec);
2066
2067     this->precision = prec;
2068     return prev;
2069 }
2070
2071 /* ?precision@ios@@QBEHXZ */
2072 /* ?precision@ios@@QEBAHXZ */
2073 DEFINE_THISCALL_WRAPPER(ios_precision_get, 4)
2074 int __thiscall ios_precision_get(const ios *this)
2075 {
2076     TRACE("(%p)\n", this);
2077     return this->precision;
2078 }
2079
2080 /* ?pword@ios@@QBEAAPAXH@Z */
2081 /* ?pword@ios@@QEBAAEAPEAXH@Z */
2082 DEFINE_THISCALL_WRAPPER(ios_pword, 8)
2083 void** __thiscall ios_pword(const ios *this, int index)
2084 {
2085     TRACE("(%p %d)\n", this, index);
2086     return (void**)&ios_statebuf[index];
2087 }
2088
2089 /* ?rdbuf@ios@@QBEPAVstreambuf@@XZ */
2090 /* ?rdbuf@ios@@QEBAPEAVstreambuf@@XZ */
2091 DEFINE_THISCALL_WRAPPER(ios_rdbuf, 4)
2092 streambuf* __thiscall ios_rdbuf(const ios *this)
2093 {
2094     TRACE("(%p)\n", this);
2095     return this->sb;
2096 }
2097
2098 /* ?rdstate@ios@@QBEHXZ */
2099 /* ?rdstate@ios@@QEBAHXZ */
2100 DEFINE_THISCALL_WRAPPER(ios_rdstate, 4)
2101 int __thiscall ios_rdstate(const ios *this)
2102 {
2103     TRACE("(%p)\n", this);
2104     return this->state;
2105 }
2106
2107 /* ?setf@ios@@QAEJJ@Z */
2108 /* ?setf@ios@@QEAAJJ@Z */
2109 DEFINE_THISCALL_WRAPPER(ios_setf, 8)
2110 LONG __thiscall ios_setf(ios *this, LONG flags)
2111 {
2112     LONG prev = this->flags;
2113
2114     TRACE("(%p %x)\n", this, flags);
2115
2116     ios_lock(this);
2117     this->flags |= flags;
2118     ios_unlock(this);
2119     return prev;
2120 }
2121
2122 /* ?setf@ios@@QAEJJJ@Z */
2123 /* ?setf@ios@@QEAAJJJ@Z */
2124 DEFINE_THISCALL_WRAPPER(ios_setf_mask, 12)
2125 LONG __thiscall ios_setf_mask(ios *this, LONG flags, LONG mask)
2126 {
2127     LONG prev = this->flags;
2128
2129     TRACE("(%p %x %x)\n", this, flags, mask);
2130
2131     ios_lock(this);
2132     this->flags = (this->flags & (~mask)) | (flags & mask);
2133     ios_unlock(this);
2134     return prev;
2135 }
2136
2137 /* ?setlock@ios@@QAAXXZ */
2138 /* ?setlock@ios@@QEAAXXZ */
2139 void __cdecl ios_setlock(ios *this)
2140 {
2141     TRACE("(%p)\n", this);
2142     this->do_lock--;
2143     if (this->sb)
2144         streambuf_setlock(this->sb);
2145 }
2146
2147 /* ?sync_with_stdio@ios@@SAXXZ */
2148 void __cdecl ios_sync_with_stdio(void)
2149 {
2150     FIXME("() stub\n");
2151 }
2152
2153 /* ?tie@ios@@QAEPAVostream@@PAV2@@Z */
2154 /* ?tie@ios@@QEAAPEAVostream@@PEAV2@@Z */
2155 DEFINE_THISCALL_WRAPPER(ios_tie_set, 8)
2156 ostream* __thiscall ios_tie_set(ios *this, ostream *ostr)
2157 {
2158     ostream *prev = this->tie;
2159
2160     TRACE("(%p %p)\n", this, ostr);
2161
2162     this->tie = ostr;
2163     return prev;
2164 }
2165
2166 /* ?tie@ios@@QBEPAVostream@@XZ */
2167 /* ?tie@ios@@QEBAPEAVostream@@XZ */
2168 DEFINE_THISCALL_WRAPPER(ios_tie_get, 4)
2169 ostream* __thiscall ios_tie_get(const ios *this)
2170 {
2171     TRACE("(%p)\n", this);
2172     return this->tie;
2173 }
2174
2175 /* ?unlock@ios@@QAAXXZ */
2176 /* ?unlock@ios@@QEAAXXZ */
2177 void __cdecl ios_unlock(ios *this)
2178 {
2179     TRACE("(%p)\n", this);
2180     if (this->do_lock < 0)
2181         LeaveCriticalSection(&this->lock);
2182 }
2183
2184 /* ?unlockbuf@ios@@QAAXXZ */
2185 /* ?unlockbuf@ios@@QEAAXXZ */
2186 void __cdecl ios_unlockbuf(ios *this)
2187 {
2188     TRACE("(%p)\n", this);
2189     streambuf_unlock(this->sb);
2190 }
2191
2192 /* ?unlockc@ios@@KAXXZ */
2193 void __cdecl ios_unlockc(void)
2194 {
2195     TRACE("()\n");
2196     LeaveCriticalSection(&ios_static_lock);
2197 }
2198
2199 /* ?unsetf@ios@@QAEJJ@Z */
2200 /* ?unsetf@ios@@QEAAJJ@Z */
2201 DEFINE_THISCALL_WRAPPER(ios_unsetf, 8)
2202 LONG __thiscall ios_unsetf(ios *this, LONG flags)
2203 {
2204     LONG prev = this->flags;
2205
2206     TRACE("(%p %x)\n", this, flags);
2207
2208     ios_lock(this);
2209     this->flags &= ~flags;
2210     ios_unlock(this);
2211     return prev;
2212 }
2213
2214 /* ?width@ios@@QAEHH@Z */
2215 /* ?width@ios@@QEAAHH@Z */
2216 DEFINE_THISCALL_WRAPPER(ios_width_set, 8)
2217 int __thiscall ios_width_set(ios *this, int width)
2218 {
2219     int prev = this->width;
2220
2221     TRACE("(%p %d)\n", this, width);
2222
2223     this->width = width;
2224     return prev;
2225 }
2226
2227 /* ?width@ios@@QBEHXZ */
2228 /* ?width@ios@@QEBAHXZ */
2229 DEFINE_THISCALL_WRAPPER(ios_width_get, 4)
2230 int __thiscall ios_width_get(const ios *this)
2231 {
2232     TRACE("(%p)\n", this);
2233     return this->width;
2234 }
2235
2236 /* ?xalloc@ios@@SAHXZ */
2237 int __cdecl ios_xalloc(void)
2238 {
2239     int ret;
2240
2241     TRACE("()\n");
2242
2243     ios_lockc();
2244     ret = (ios_curindex < STATEBUF_SIZE-1) ? ++ios_curindex : -1;
2245     ios_unlockc();
2246     return ret;
2247 }
2248
2249 static inline ios* ostream_get_ios(const ostream *this)
2250 {
2251     return (ios*)((char*)this + this->vbtable[1]);
2252 }
2253
2254 static inline ios* ostream_to_ios(const ostream *this)
2255 {
2256     return (ios*)((char*)this + ostream_vbtable[1]);
2257 }
2258
2259 static inline ostream* ios_to_ostream(const ios *base)
2260 {
2261     return (ostream*)((char*)base - ostream_vbtable[1]);
2262 }
2263
2264 /* ??0ostream@@QAE@PAVstreambuf@@@Z */
2265 /* ??0ostream@@QEAA@PEAVstreambuf@@@Z */
2266 DEFINE_THISCALL_WRAPPER(ostream_sb_ctor, 12)
2267 ostream* __thiscall ostream_sb_ctor(ostream *this, streambuf *sb, BOOL virt_init)
2268 {
2269     ios *base;
2270
2271     TRACE("(%p %p %d)\n", this, sb, virt_init);
2272
2273     if (virt_init) {
2274         this->vbtable = ostream_vbtable;
2275         base = ostream_get_ios(this);
2276         ios_sb_ctor(base, sb);
2277     } else {
2278         base = ostream_get_ios(this);
2279         ios_init(base, sb);
2280     }
2281     base->vtable = &MSVCP_ostream_vtable;
2282     this->unknown = 0;
2283     return this;
2284 }
2285
2286 /* ??0ostream@@IAE@ABV0@@Z */
2287 /* ??0ostream@@IEAA@AEBV0@@Z */
2288 DEFINE_THISCALL_WRAPPER(ostream_copy_ctor, 12)
2289 ostream* __thiscall ostream_copy_ctor(ostream *this, const ostream *copy, BOOL virt_init)
2290 {
2291     return ostream_sb_ctor(this, ostream_get_ios(copy)->sb, virt_init);
2292 }
2293
2294 /* ??0ostream@@IAE@XZ */
2295 /* ??0ostream@@IEAA@XZ */
2296 DEFINE_THISCALL_WRAPPER(ostream_ctor, 8)
2297 ostream* __thiscall ostream_ctor(ostream *this, BOOL virt_init)
2298 {
2299     ios *base;
2300
2301     TRACE("(%p %d)\n", this, virt_init);
2302
2303     if (virt_init) {
2304         this->vbtable = ostream_vbtable;
2305         base = ostream_get_ios(this);
2306         ios_ctor(base);
2307     } else
2308         base = ostream_get_ios(this);
2309     base->vtable = &MSVCP_ostream_vtable;
2310     this->unknown = 0;
2311     return this;
2312 }
2313
2314 /* ??1ostream@@UAE@XZ */
2315 /* ??1ostream@@UEAA@XZ */
2316 DEFINE_THISCALL_WRAPPER(ostream_dtor, 4)
2317 void __thiscall ostream_dtor(ios *base)
2318 {
2319     ostream *this = ios_to_ostream(base);
2320
2321     TRACE("(%p)\n", this);
2322 }
2323
2324 /* ??4ostream@@IAEAAV0@PAVstreambuf@@@Z */
2325 /* ??4ostream@@IEAAAEAV0@PEAVstreambuf@@@Z */
2326 DEFINE_THISCALL_WRAPPER(ostream_assign_sb, 8)
2327 ostream* __thiscall ostream_assign_sb(ostream *this, streambuf *sb)
2328 {
2329     ios *base = ostream_get_ios(this);
2330
2331     TRACE("(%p %p)\n", this, sb);
2332
2333     ios_init(base, sb);
2334     base->state &= IOSTATE_badbit;
2335     base->delbuf = 0;
2336     base->tie = NULL;
2337     base->flags = 0;
2338     base->precision = 6;
2339     base->fill = ' ';
2340     base->width = 0;
2341     return this;
2342 }
2343
2344 /* ??4ostream@@IAEAAV0@ABV0@@Z */
2345 /* ??4ostream@@IEAAAEAV0@AEBV0@@Z */
2346 DEFINE_THISCALL_WRAPPER(ostream_assign, 8)
2347 ostream* __thiscall ostream_assign(ostream *this, const ostream *rhs)
2348 {
2349     ios *base_rhs = ostream_get_ios(rhs);
2350
2351     TRACE("(%p %p)\n", this, rhs);
2352
2353     return ostream_assign_sb(this, base_rhs->sb);
2354 }
2355
2356 /* ??_Dostream@@QAEXXZ */
2357 /* ??_Dostream@@QEAAXXZ */
2358 DEFINE_THISCALL_WRAPPER(ostream_vbase_dtor, 4)
2359 void __thiscall ostream_vbase_dtor(ostream *this)
2360 {
2361     ios *base = ostream_to_ios(this);
2362
2363     TRACE("(%p)\n", this);
2364
2365     ostream_dtor(base);
2366     ios_dtor(base);
2367 }
2368
2369 /* ??_Eostream@@UAEPAXI@Z */
2370 DEFINE_THISCALL_WRAPPER(ostream_vector_dtor, 8)
2371 ostream* __thiscall ostream_vector_dtor(ios *base, unsigned int flags)
2372 {
2373     ostream *this = ios_to_ostream(base);
2374
2375     TRACE("(%p %x)\n", this, flags);
2376
2377     if (flags & 2) {
2378         /* we have an array, with the number of elements stored before the first object */
2379         INT_PTR i, *ptr = (INT_PTR *)this-1;
2380
2381         for (i = *ptr-1; i >= 0; i--)
2382             ostream_vbase_dtor(this+i);
2383         MSVCRT_operator_delete(ptr);
2384     } else {
2385         ostream_vbase_dtor(this);
2386         if (flags & 1)
2387             MSVCRT_operator_delete(this);
2388     }
2389     return this;
2390 }
2391
2392 /* ??_Gostream@@UAEPAXI@Z */
2393 DEFINE_THISCALL_WRAPPER(ostream_scalar_dtor, 8)
2394 ostream* __thiscall ostream_scalar_dtor(ios *base, unsigned int flags)
2395 {
2396     ostream *this = ios_to_ostream(base);
2397
2398     TRACE("(%p %x)\n", this, flags);
2399
2400     ostream_vbase_dtor(this);
2401     if (flags & 1) MSVCRT_operator_delete(this);
2402     return this;
2403 }
2404
2405 /* ?flush@ostream@@QAEAAV1@XZ */
2406 /* ?flush@ostream@@QEAAAEAV1@XZ */
2407 DEFINE_THISCALL_WRAPPER(ostream_flush, 4)
2408 ostream* __thiscall ostream_flush(ostream *this)
2409 {
2410     ios *base = ostream_get_ios(this);
2411
2412     TRACE("(%p)\n", this);
2413
2414     ios_lockbuf(base);
2415     if (call_streambuf_sync(base->sb) == EOF)
2416         ios_clear(base, base->state | IOSTATE_failbit);
2417     ios_unlockbuf(base);
2418     return this;
2419 }
2420
2421 /* ?opfx@ostream@@QAEHXZ */
2422 /* ?opfx@ostream@@QEAAHXZ */
2423 DEFINE_THISCALL_WRAPPER(ostream_opfx, 4)
2424 int __thiscall ostream_opfx(ostream *this)
2425 {
2426     ios *base = ostream_get_ios(this);
2427
2428     TRACE("(%p)\n", this);
2429
2430     if (!ios_good(base)) {
2431         ios_clear(base, base->state | IOSTATE_failbit);
2432         return 0;
2433     }
2434     ios_lock(base);
2435     ios_lockbuf(base);
2436     if (base->tie)
2437         ostream_flush(base->tie);
2438     return 1;
2439 }
2440
2441 /* ?osfx@ostream@@QAEXXZ */
2442 /* ?osfx@ostream@@QEAAXXZ */
2443 DEFINE_THISCALL_WRAPPER(ostream_osfx, 4)
2444 void __thiscall ostream_osfx(ostream *this)
2445 {
2446     ios *base = ostream_get_ios(this);
2447
2448     TRACE("(%p)\n", this);
2449
2450     ios_unlockbuf(base);
2451     ios_width_set(base, 0);
2452     if (base->flags & FLAGS_unitbuf)
2453         ostream_flush(this);
2454     if (base->flags & FLAGS_stdio) {
2455         fflush(stdout);
2456         fflush(stderr);
2457     }
2458     ios_unlock(base);
2459 }
2460
2461 /* ?put@ostream@@QAEAAV1@D@Z */
2462 /* ?put@ostream@@QEAAAEAV1@D@Z */
2463 DEFINE_THISCALL_WRAPPER(ostream_put_char, 8)
2464 ostream* __thiscall ostream_put_char(ostream *this, char c)
2465 {
2466     ios *base = ostream_get_ios(this);
2467
2468     TRACE("(%p %c)\n", this, c);
2469
2470     if (ostream_opfx(this)) {
2471         if (streambuf_sputc(base->sb, c) == EOF)
2472             base->state = IOSTATE_badbit | IOSTATE_failbit;
2473         ostream_osfx(this);
2474     }
2475     return this;
2476 }
2477
2478 /* ?put@ostream@@QAEAAV1@C@Z */
2479 /* ?put@ostream@@QEAAAEAV1@C@Z */
2480 DEFINE_THISCALL_WRAPPER(ostream_put_signed_char, 8)
2481 ostream* __thiscall ostream_put_signed_char(ostream *this, signed char c)
2482 {
2483     return ostream_put_char(this, (char) c);
2484 }
2485
2486 /* ?put@ostream@@QAEAAV1@E@Z */
2487 /* ?put@ostream@@QEAAAEAV1@E@Z */
2488 DEFINE_THISCALL_WRAPPER(ostream_put_unsigned_char, 8)
2489 ostream* __thiscall ostream_put_unsigned_char(ostream *this, unsigned char c)
2490 {
2491     return ostream_put_char(this, (char) c);
2492 }
2493
2494 /* ?seekp@ostream@@QAEAAV1@J@Z */
2495 /* ?seekp@ostream@@QEAAAEAV1@J@Z */
2496 DEFINE_THISCALL_WRAPPER(ostream_seekp, 8)
2497 ostream* __thiscall ostream_seekp(ostream *this, streampos pos)
2498 {
2499     ios *base = ostream_get_ios(this);
2500
2501     TRACE("(%p %d)\n", this, pos);
2502
2503     ios_lockbuf(base);
2504     if (streambuf_seekpos(base->sb, pos, OPENMODE_out) == EOF)
2505         ios_clear(base, base->state | IOSTATE_failbit);
2506     ios_unlockbuf(base);
2507     return this;
2508 }
2509
2510 /* ?seekp@ostream@@QAEAAV1@JW4seek_dir@ios@@@Z */
2511 /* ?seekp@ostream@@QEAAAEAV1@JW4seek_dir@ios@@@Z */
2512 DEFINE_THISCALL_WRAPPER(ostream_seekp_offset, 12)
2513 ostream* __thiscall ostream_seekp_offset(ostream *this, streamoff off, ios_seek_dir dir)
2514 {
2515     ios *base = ostream_get_ios(this);
2516
2517     TRACE("(%p %d %d)\n", this, off, dir);
2518
2519     ios_lockbuf(base);
2520     if (call_streambuf_seekoff(base->sb, off, dir, OPENMODE_out) == EOF)
2521         ios_clear(base, base->state | IOSTATE_failbit);
2522     ios_unlockbuf(base);
2523     return this;
2524 }
2525
2526 /* ?tellp@ostream@@QAEJXZ */
2527 /* ?tellp@ostream@@QEAAJXZ */
2528 DEFINE_THISCALL_WRAPPER(ostream_tellp, 4)
2529 streampos __thiscall ostream_tellp(ostream *this)
2530 {
2531     ios *base = ostream_get_ios(this);
2532     streampos pos;
2533
2534     TRACE("(%p)\n", this);
2535
2536     ios_lockbuf(base);
2537     if ((pos = call_streambuf_seekoff(base->sb, 0, SEEKDIR_cur, OPENMODE_out)) == EOF)
2538         ios_clear(base, base->state | IOSTATE_failbit);
2539     ios_unlockbuf(base);
2540     return pos;
2541 }
2542
2543 /* ?write@ostream@@QAEAAV1@PBDH@Z */
2544 /* ?write@ostream@@QEAAAEAV1@PEBDH@Z */
2545 DEFINE_THISCALL_WRAPPER(ostream_write_char, 12)
2546 ostream* __thiscall ostream_write_char(ostream *this, const char *str, int count)
2547 {
2548     ios *base = ostream_get_ios(this);
2549
2550     TRACE("(%p %p %d)\n", this, str, count);
2551
2552     if (ostream_opfx(this)) {
2553         if (streambuf_sputn(base->sb, str, count) != count)
2554             base->state = IOSTATE_badbit | IOSTATE_failbit;
2555         ostream_osfx(this);
2556     }
2557     return this;
2558 }
2559
2560 /* ?write@ostream@@QAEAAV1@PBCH@Z */
2561 /* ?write@ostream@@QEAAAEAV1@PEBCH@Z */
2562 DEFINE_THISCALL_WRAPPER(ostream_write_signed_char, 12)
2563 ostream* __thiscall ostream_write_signed_char(ostream *this, const signed char *str, int count)
2564 {
2565     return ostream_write_char(this, (const char*) str, count);
2566 }
2567
2568 /* ?write@ostream@@QAEAAV1@PBEH@Z */
2569 /* ?write@ostream@@QEAAAEAV1@PEBEH@Z */
2570 DEFINE_THISCALL_WRAPPER(ostream_write_unsigned_char, 12)
2571 ostream* __thiscall ostream_write_unsigned_char(ostream *this, const unsigned char *str, int count)
2572 {
2573     return ostream_write_char(this, (const char*) str, count);
2574 }
2575
2576 /* ?writepad@ostream@@AAEAAV1@PBD0@Z */
2577 /* ?writepad@ostream@@AEAAAEAV1@PEBD0@Z */
2578 DEFINE_THISCALL_WRAPPER(ostream_writepad, 12)
2579 ostream* __thiscall ostream_writepad(ostream *this, const char *str1, const char *str2)
2580 {
2581     ios *base = ostream_get_ios(this);
2582     int len1 = strlen(str1), len2 = strlen(str2), i;
2583
2584     TRACE("(%p %p %p)\n", this, str1, str2);
2585
2586     /* left of the padding */
2587     if (base->flags & (FLAGS_left|FLAGS_internal)) {
2588         if (streambuf_sputn(base->sb, str1, len1) != len1)
2589             base->state |= IOSTATE_failbit | IOSTATE_badbit;
2590         if (!(base->flags & FLAGS_internal))
2591             if (streambuf_sputn(base->sb, str2, len2) != len2)
2592                 base->state |= IOSTATE_failbit | IOSTATE_badbit;
2593     }
2594     /* add padding to fill the width */
2595     for (i = len1 + len2; i < base->width; i++)
2596         if (streambuf_sputc(base->sb, base->fill) == EOF)
2597             base->state |= IOSTATE_failbit | IOSTATE_badbit;
2598     /* right of the padding */
2599     if ((base->flags & (FLAGS_left|FLAGS_internal)) != FLAGS_left) {
2600         if (!(base->flags & (FLAGS_left|FLAGS_internal)))
2601             if (streambuf_sputn(base->sb, str1, len1) != len1)
2602                 base->state |= IOSTATE_failbit | IOSTATE_badbit;
2603         if (streambuf_sputn(base->sb, str2, len2) != len2)
2604             base->state |= IOSTATE_failbit | IOSTATE_badbit;
2605     }
2606     return this;
2607 }
2608
2609 static ostream* ostream_internal_print_integer(ostream *ostr, int n, BOOL unsig, BOOL shrt)
2610 {
2611     ios *base = ostream_get_ios(ostr);
2612     char prefix_str[3] = {0}, number_str[12], sprintf_fmt[4] = {'%','d',0};
2613
2614     TRACE("(%p %d %d %d)\n", ostr, n, unsig, shrt);
2615
2616     if (ostream_opfx(ostr)) {
2617         if (base->flags & FLAGS_hex) {
2618             sprintf_fmt[1] = (base->flags & FLAGS_uppercase) ? 'X' : 'x';
2619             if (base->flags & FLAGS_showbase) {
2620                 prefix_str[0] = '0';
2621                 prefix_str[1] = (base->flags & FLAGS_uppercase) ? 'X' : 'x';
2622             }
2623         } else if (base->flags & FLAGS_oct) {
2624             sprintf_fmt[1]  = 'o';
2625             if (base->flags & FLAGS_showbase)
2626                 prefix_str[0] = '0';
2627         } else { /* FLAGS_dec */
2628             if (unsig)
2629                 sprintf_fmt[1] = 'u';
2630             if ((base->flags & FLAGS_showpos) && n != 0 && (unsig || n > 0))
2631                 prefix_str[0] = '+';
2632         }
2633
2634         if (shrt) {
2635             sprintf_fmt[2] = sprintf_fmt[1];
2636             sprintf_fmt[1] = 'h';
2637         }
2638
2639         if (sprintf(number_str, sprintf_fmt, n) > 0)
2640             ostream_writepad(ostr, prefix_str, number_str);
2641         else
2642             base->state |= IOSTATE_failbit;
2643         ostream_osfx(ostr);
2644     }
2645     return ostr;
2646 }
2647
2648 static ostream* ostream_internal_print_float(ostream *ostr, double d, BOOL dbl)
2649 {
2650     ios *base = ostream_get_ios(ostr);
2651     char prefix_str[2] = {0}, number_str[24], sprintf_fmt[6] = {'%','.','*','f',0};
2652     int prec, max_prec = dbl ? 15 : 6;
2653     int str_length = 1; /* null end char */
2654
2655     TRACE("(%p %lf %d)\n", ostr, d, dbl);
2656
2657     if (ostream_opfx(ostr)) {
2658         if ((base->flags & FLAGS_showpos) && d > 0) {
2659             prefix_str[0] = '+';
2660             str_length++; /* plus sign */
2661         }
2662         if ((base->flags & (FLAGS_scientific|FLAGS_fixed)) == FLAGS_scientific)
2663             sprintf_fmt[3] = (base->flags & FLAGS_uppercase) ? 'E' : 'e';
2664         else if ((base->flags & (FLAGS_scientific|FLAGS_fixed)) != FLAGS_fixed)
2665             sprintf_fmt[3] = (base->flags & FLAGS_uppercase) ? 'G' : 'g';
2666         if (base->flags & FLAGS_showpoint) {
2667             sprintf_fmt[4] = sprintf_fmt[3];
2668             sprintf_fmt[3] = sprintf_fmt[2];
2669             sprintf_fmt[2] = sprintf_fmt[1];
2670             sprintf_fmt[1] = '#';
2671         }
2672
2673         prec = (base->precision >= 0 && base->precision <= max_prec) ? base->precision : max_prec;
2674         str_length += _scprintf(sprintf_fmt, prec, d); /* number representation */
2675         if (str_length > 24) {
2676             /* when the output length exceeds 24 characters, Windows prints an empty string with padding */
2677             ostream_writepad(ostr, "", "");
2678         } else {
2679             if (sprintf(number_str, sprintf_fmt, prec, d) > 0)
2680                 ostream_writepad(ostr, prefix_str, number_str);
2681             else
2682                 base->state |= IOSTATE_failbit;
2683         }
2684         ostream_osfx(ostr);
2685     }
2686     return ostr;
2687 }
2688
2689 /* ??6ostream@@QAEAAV0@C@Z */
2690 /* ??6ostream@@QEAAAEAV0@C@Z */
2691 /* ??6ostream@@QAEAAV0@D@Z */
2692 /* ??6ostream@@QEAAAEAV0@D@Z */
2693 DEFINE_THISCALL_WRAPPER(ostream_print_char, 8)
2694 ostream* __thiscall ostream_print_char(ostream *this, char c)
2695 {
2696     const char c_str[2] = {c, 0};
2697
2698     TRACE("(%p %c)\n", this, c);
2699
2700     if (ostream_opfx(this)) {
2701         ostream_writepad(this, "", c_str);
2702         ostream_osfx(this);
2703     }
2704     return this;
2705 }
2706
2707 /* ??6ostream@@QAEAAV0@E@Z */
2708 /* ??6ostream@@QEAAAEAV0@E@Z */
2709 DEFINE_THISCALL_WRAPPER(ostream_print_unsigned_char, 8)
2710 ostream* __thiscall ostream_print_unsigned_char(ostream *this, unsigned char c)
2711 {
2712     return ostream_print_char(this, c);
2713 }
2714
2715 /* ??6ostream@@QAEAAV0@PBC@Z */
2716 /* ??6ostream@@QEAAAEAV0@PEBC@Z */
2717 /* ??6ostream@@QAEAAV0@PBD@Z */
2718 /* ??6ostream@@QEAAAEAV0@PEBD@Z */
2719 DEFINE_THISCALL_WRAPPER(ostream_print_str, 8)
2720 ostream* __thiscall ostream_print_str(ostream *this, const char *str)
2721 {
2722     TRACE("(%p %s)\n", this, str);
2723     if (ostream_opfx(this)) {
2724         ostream_writepad(this, "", str);
2725         ostream_osfx(this);
2726     }
2727     return this;
2728 }
2729
2730 /* ??6ostream@@QAEAAV0@PBE@Z */
2731 /* ??6ostream@@QEAAAEAV0@PEBE@Z */
2732 DEFINE_THISCALL_WRAPPER(ostream_print_unsigned_str, 8)
2733 ostream* __thiscall ostream_print_unsigned_str(ostream *this, const unsigned char *str)
2734 {
2735     return ostream_print_str(this, (const char*) str);
2736 }
2737
2738 /* ??6ostream@@QAEAAV0@F@Z */
2739 /* ??6ostream@@QEAAAEAV0@F@Z */
2740 DEFINE_THISCALL_WRAPPER(ostream_print_short, 8)
2741 ostream* __thiscall ostream_print_short(ostream *this, short n)
2742 {
2743     return ostream_internal_print_integer(this, n, FALSE, TRUE);
2744 }
2745
2746 /* ??6ostream@@QAEAAV0@G@Z */
2747 /* ??6ostream@@QEAAAEAV0@G@Z */
2748 DEFINE_THISCALL_WRAPPER(ostream_print_unsigned_short, 8)
2749 ostream* __thiscall ostream_print_unsigned_short(ostream *this, unsigned short n)
2750 {
2751     return ostream_internal_print_integer(this, n, TRUE, TRUE);
2752 }
2753
2754 /* ??6ostream@@QAEAAV0@H@Z */
2755 /* ??6ostream@@QEAAAEAV0@H@Z */
2756 /* ??6ostream@@QAEAAV0@J@Z */
2757 /* ??6ostream@@QEAAAEAV0@J@Z */
2758 DEFINE_THISCALL_WRAPPER(ostream_print_int, 8)
2759 ostream* __thiscall ostream_print_int(ostream *this, int n)
2760 {
2761     return ostream_internal_print_integer(this, n, FALSE, FALSE);
2762 }
2763
2764 /* ??6ostream@@QAEAAV0@I@Z */
2765 /* ??6ostream@@QEAAAEAV0@I@Z */
2766 /* ??6ostream@@QAEAAV0@K@Z */
2767 /* ??6ostream@@QEAAAEAV0@K@Z */
2768 DEFINE_THISCALL_WRAPPER(ostream_print_unsigned_int, 8)
2769 ostream* __thiscall ostream_print_unsigned_int(ostream *this, unsigned int n)
2770 {
2771     return ostream_internal_print_integer(this, n, TRUE, FALSE);
2772 }
2773
2774 /* ??6ostream@@QAEAAV0@M@Z */
2775 /* ??6ostream@@QEAAAEAV0@M@Z */
2776 DEFINE_THISCALL_WRAPPER(ostream_print_float, 8)
2777 ostream* __thiscall ostream_print_float(ostream *this, float f)
2778 {
2779     return ostream_internal_print_float(this, f, FALSE);
2780 }
2781
2782 /* ??6ostream@@QAEAAV0@N@Z */
2783 /* ??6ostream@@QEAAAEAV0@N@Z */
2784 /* ??6ostream@@QAEAAV0@O@Z */
2785 /* ??6ostream@@QEAAAEAV0@O@Z */
2786 DEFINE_THISCALL_WRAPPER(ostream_print_double, 12)
2787 ostream* __thiscall ostream_print_double(ostream *this, double d)
2788 {
2789     return ostream_internal_print_float(this, d, TRUE);
2790 }
2791
2792 /* ??6ostream@@QAEAAV0@PBX@Z */
2793 /* ??6ostream@@QEAAAEAV0@PEBX@Z */
2794 DEFINE_THISCALL_WRAPPER(ostream_print_ptr, 8)
2795 ostream* __thiscall ostream_print_ptr(ostream *this, const void *ptr)
2796 {
2797     ios *base = ostream_get_ios(this);
2798     char prefix_str[3] = {'0','x',0}, pointer_str[17];
2799
2800     TRACE("(%p %p)\n", this, ptr);
2801
2802     if (ostream_opfx(this)) {
2803         if (ptr && base->flags & FLAGS_uppercase)
2804             prefix_str[1] = 'X';
2805
2806         if (sprintf(pointer_str, "%p", ptr) > 0)
2807             ostream_writepad(this, prefix_str, pointer_str);
2808         else
2809             base->state |= IOSTATE_failbit;
2810         ostream_osfx(this);
2811     }
2812     return this;
2813 }
2814
2815 /* ??6ostream@@QAEAAV0@PAVstreambuf@@@Z */
2816 /* ??6ostream@@QEAAAEAV0@PEAVstreambuf@@@Z */
2817 DEFINE_THISCALL_WRAPPER(ostream_print_streambuf, 8)
2818 ostream* __thiscall ostream_print_streambuf(ostream *this, streambuf *sb)
2819 {
2820     ios *base = ostream_get_ios(this);
2821     int c;
2822
2823     TRACE("(%p %p)\n", this, sb);
2824
2825     if (ostream_opfx(this)) {
2826         while ((c = streambuf_sbumpc(sb)) != EOF) {
2827             if (streambuf_sputc(base->sb, c) == EOF) {
2828                 base->state |= IOSTATE_failbit;
2829                 break;
2830             }
2831         }
2832         ostream_osfx(this);
2833     }
2834     return this;
2835 }
2836
2837 /* ??6ostream@@QAEAAV0@P6AAAV0@AAV0@@Z@Z */
2838 /* ??6ostream@@QEAAAEAV0@P6AAEAV0@AEAV0@@Z@Z */
2839 DEFINE_THISCALL_WRAPPER(ostream_print_manip, 8)
2840 ostream* __thiscall ostream_print_manip(ostream *this, ostream* (__cdecl *func)(ostream*))
2841 {
2842     TRACE("(%p %p)\n", this, func);
2843     return func(this);
2844 }
2845
2846 /* ??6ostream@@QAEAAV0@P6AAAVios@@AAV1@@Z@Z */
2847 /* ??6ostream@@QEAAAEAV0@P6AAEAVios@@AEAV1@@Z@Z */
2848 DEFINE_THISCALL_WRAPPER(ostream_print_ios_manip, 8)
2849 ostream* __thiscall ostream_print_ios_manip(ostream *this, ios* (__cdecl *func)(ios*))
2850 {
2851     TRACE("(%p %p)\n", this, func);
2852     func(ostream_get_ios(this));
2853     return this;
2854 }
2855
2856 /* ?endl@@YAAAVostream@@AAV1@@Z */
2857 /* ?endl@@YAAEAVostream@@AEAV1@@Z */
2858 ostream* __cdecl ostream_endl(ostream *this)
2859 {
2860    TRACE("(%p)\n", this);
2861    ostream_put_char(this, '\n');
2862    return ostream_flush(this);
2863 }
2864
2865 /* ?ends@@YAAAVostream@@AAV1@@Z */
2866 /* ?ends@@YAAEAVostream@@AEAV1@@Z */
2867 ostream* __cdecl ostream_ends(ostream *this)
2868 {
2869    TRACE("(%p)\n", this);
2870    return ostream_put_char(this, 0);
2871 }
2872
2873 /* ?flush@@YAAAVostream@@AAV1@@Z */
2874 /* ?flush@@YAAEAVostream@@AEAV1@@Z */
2875 ostream* __cdecl ostream_flush_manip(ostream *this)
2876 {
2877    TRACE("(%p)\n", this);
2878    return ostream_flush(this);
2879 }
2880
2881 static inline ios* istream_get_ios(const istream *this)
2882 {
2883     return (ios*)((char*)this + this->vbtable[1]);
2884 }
2885
2886 static inline ios* istream_to_ios(const istream *this)
2887 {
2888     return (ios*)((char*)this + istream_vbtable[1]);
2889 }
2890
2891 static inline istream* ios_to_istream(const ios *base)
2892 {
2893     return (istream*)((char*)base - istream_vbtable[1]);
2894 }
2895
2896 /* ??0istream@@QAE@PAVstreambuf@@@Z */
2897 /* ??0istream@@QEAA@PEAVstreambuf@@@Z */
2898 DEFINE_THISCALL_WRAPPER(istream_sb_ctor, 12)
2899 istream* __thiscall istream_sb_ctor(istream *this, streambuf *sb, BOOL virt_init)
2900 {
2901     ios *base;
2902
2903     TRACE("(%p %p %d)\n", this, sb, virt_init);
2904
2905     if (virt_init) {
2906         this->vbtable = istream_vbtable;
2907         base = istream_get_ios(this);
2908         ios_sb_ctor(base, sb);
2909     } else {
2910         base = istream_get_ios(this);
2911         ios_init(base, sb);
2912     }
2913     base->vtable = &MSVCP_istream_vtable;
2914     base->flags |= FLAGS_skipws;
2915     this->extract_delim = 0;
2916     this->count = 0;
2917     return this;
2918 }
2919
2920 /* ??0istream@@IAE@ABV0@@Z */
2921 /* ??0istream@@IEAA@AEBV0@@Z */
2922 DEFINE_THISCALL_WRAPPER(istream_copy_ctor, 12)
2923 istream* __thiscall istream_copy_ctor(istream *this, const istream *copy, BOOL virt_init)
2924 {
2925     return istream_sb_ctor(this, istream_get_ios(copy)->sb, virt_init);
2926 }
2927
2928 /* ??0istream@@IAE@XZ */
2929 /* ??0istream@@IEAA@XZ */
2930 DEFINE_THISCALL_WRAPPER(istream_ctor, 8)
2931 istream* __thiscall istream_ctor(istream *this, BOOL virt_init)
2932 {
2933     ios *base;
2934
2935     TRACE("(%p %d)\n", this, virt_init);
2936
2937     if (virt_init) {
2938         this->vbtable = istream_vbtable;
2939         base = istream_get_ios(this);
2940         ios_ctor(base);
2941     } else
2942         base = istream_get_ios(this);
2943     base->vtable = &MSVCP_istream_vtable;
2944     base->flags |= FLAGS_skipws;
2945     this->extract_delim = 0;
2946     this->count = 0;
2947     return this;
2948 }
2949
2950 /* ??1istream@@UAE@XZ */
2951 /* ??1istream@@UEAA@XZ */
2952 DEFINE_THISCALL_WRAPPER(istream_dtor, 4)
2953 void __thiscall istream_dtor(ios *base)
2954 {
2955     istream *this = ios_to_istream(base);
2956
2957     TRACE("(%p)\n", this);
2958 }
2959
2960 /* ??4istream@@IAEAAV0@PAVstreambuf@@@Z */
2961 /* ??4istream@@IEAAAEAV0@PEAVstreambuf@@@Z */
2962 DEFINE_THISCALL_WRAPPER(istream_assign_sb, 8)
2963 istream* __thiscall istream_assign_sb(istream *this, streambuf *sb)
2964 {
2965     ios *base = istream_get_ios(this);
2966
2967     TRACE("(%p %p)\n", this, sb);
2968
2969     ios_init(base, sb);
2970     base->state &= IOSTATE_badbit;
2971     base->delbuf = 0;
2972     base->tie = NULL;
2973     base->flags = FLAGS_skipws;
2974     base->precision = 6;
2975     base->fill = ' ';
2976     base->width = 0;
2977     this->count = 0;
2978     return this;
2979 }
2980
2981 /* ??4istream@@IAEAAV0@ABV0@@Z */
2982 /* ??4istream@@IEAAAEAV0@AEBV0@@Z */
2983 DEFINE_THISCALL_WRAPPER(istream_assign, 8)
2984 istream* __thiscall istream_assign(istream *this, const istream *rhs)
2985 {
2986     return istream_assign_sb(this, istream_get_ios(rhs)->sb);
2987 }
2988
2989 /* ??_Distream@@QAEXXZ */
2990 /* ??_Distream@@QEAAXXZ */
2991 DEFINE_THISCALL_WRAPPER(istream_vbase_dtor, 4)
2992 void __thiscall istream_vbase_dtor(istream *this)
2993 {
2994     ios *base = istream_to_ios(this);
2995
2996     TRACE("(%p)\n", this);
2997
2998     istream_dtor(base);
2999     ios_dtor(base);
3000 }
3001
3002 /* ??_Eistream@@UAEPAXI@Z */
3003 DEFINE_THISCALL_WRAPPER(istream_vector_dtor, 8)
3004 istream* __thiscall istream_vector_dtor(ios *base, unsigned int flags)
3005 {
3006     istream *this = ios_to_istream(base);
3007
3008     TRACE("(%p %x)\n", this, flags);
3009
3010     if (flags & 2) {
3011         /* we have an array, with the number of elements stored before the first object */
3012         INT_PTR i, *ptr = (INT_PTR *)this-1;
3013
3014         for (i = *ptr-1; i >= 0; i--)
3015             istream_vbase_dtor(this+i);
3016         MSVCRT_operator_delete(ptr);
3017     } else {
3018         istream_vbase_dtor(this);
3019         if (flags & 1)
3020             MSVCRT_operator_delete(this);
3021     }
3022     return this;
3023 }
3024
3025 /* ??_Gistream@@UAEPAXI@Z */
3026 DEFINE_THISCALL_WRAPPER(istream_scalar_dtor, 8)
3027 istream* __thiscall istream_scalar_dtor(ios *base, unsigned int flags)
3028 {
3029     istream *this = ios_to_istream(base);
3030
3031     TRACE("(%p %x)\n", this, flags);
3032
3033     istream_vbase_dtor(this);
3034     if (flags & 1) MSVCRT_operator_delete(this);
3035     return this;
3036 }
3037
3038 /* ?eatwhite@istream@@QAEXXZ */
3039 /* ?eatwhite@istream@@QEAAXXZ */
3040 DEFINE_THISCALL_WRAPPER(istream_eatwhite, 4)
3041 void __thiscall istream_eatwhite(istream *this)
3042 {
3043     ios *base = istream_get_ios(this);
3044     int c;
3045
3046     TRACE("(%p)\n", this);
3047
3048     ios_lockbuf(base);
3049     for (c = streambuf_sgetc(base->sb); isspace(c); c = streambuf_snextc(base->sb));
3050     ios_unlockbuf(base);
3051     if (c == EOF)
3052         ios_clear(base, base->state | IOSTATE_eofbit);
3053 }
3054
3055 /* ?gcount@istream@@QBEHXZ */
3056 /* ?gcount@istream@@QEBAHXZ */
3057 DEFINE_THISCALL_WRAPPER(istream_gcount, 4)
3058 int __thiscall istream_gcount(const istream *this)
3059 {
3060     TRACE("(%p)\n", this);
3061     return this->count;
3062 }
3063
3064 /* ?ipfx@istream@@QAEHH@Z */
3065 /* ?ipfx@istream@@QEAAHH@Z */
3066 DEFINE_THISCALL_WRAPPER(istream_ipfx, 8)
3067 int __thiscall istream_ipfx(istream *this, int need)
3068 {
3069     ios *base = istream_get_ios(this);
3070
3071     TRACE("(%p %d)\n", this, need);
3072
3073     if (need)
3074         this->count = 0;
3075     if (!ios_good(base)) {
3076         ios_clear(base, base->state | IOSTATE_failbit);
3077         return 0;
3078     }
3079     ios_lock(base);
3080     ios_lockbuf(base);
3081     if (base->tie && (!need || streambuf_in_avail(base->sb) < need))
3082         ostream_flush(base->tie);
3083     if ((base->flags & FLAGS_skipws) && !need) {
3084         istream_eatwhite(this);
3085         if (base->state & IOSTATE_eofbit) {
3086             base->state |= IOSTATE_failbit;
3087             ios_unlockbuf(base);
3088             ios_unlock(base);
3089             return 0;
3090         }
3091     }
3092     return 1;
3093 }
3094
3095 /* ?isfx@istream@@QAEXXZ */
3096 /* ?isfx@istream@@QEAAXXZ */
3097 DEFINE_THISCALL_WRAPPER(istream_isfx, 4)
3098 void __thiscall istream_isfx(istream *this)
3099 {
3100     ios *base = istream_get_ios(this);
3101
3102     TRACE("(%p)\n", this);
3103
3104     ios_unlockbuf(base);
3105     ios_unlock(base);
3106 }
3107
3108 /* ?get@istream@@IAEAAV1@PADHH@Z */
3109 /* ?get@istream@@IEAAAEAV1@PEADHH@Z */
3110 DEFINE_THISCALL_WRAPPER(istream_get_str_delim, 16)
3111 istream* __thiscall istream_get_str_delim(istream *this, char *str, int count, int delim)
3112 {
3113     FIXME("(%p %p %d %d) stub\n", this, str, count, delim);
3114     return this;
3115 }
3116
3117 /* ?get@istream@@QAEAAV1@PACHD@Z */
3118 /* ?get@istream@@QEAAAEAV1@PEACHD@Z */
3119 /* ?get@istream@@QAEAAV1@PADHD@Z */
3120 /* ?get@istream@@QEAAAEAV1@PEADHD@Z */
3121 DEFINE_THISCALL_WRAPPER(istream_get_str, 16)
3122 istream* __thiscall istream_get_str(istream *this, char *str, int count, char delim)
3123 {
3124     FIXME("(%p %p %d %c) stub\n", this, str, count, delim);
3125     return this;
3126 }
3127
3128 /* ?get@istream@@QAEAAV1@PAEHD@Z */
3129 /* ?get@istream@@QEAAAEAV1@PEAEHD@Z */
3130 DEFINE_THISCALL_WRAPPER(istream_get_unsigned_str, 16)
3131 istream* __thiscall istream_get_unsigned_str(istream *this, unsigned char *str, int count, char delim)
3132 {
3133     FIXME("(%p %p %d %c) stub\n", this, str, count, delim);
3134     return this;
3135 }
3136
3137 /* ?get@istream@@QAEAAV1@AAC@Z */
3138 /* ?get@istream@@QEAAAEAV1@AEAC@Z */
3139 /* ?get@istream@@QAEAAV1@AAD@Z */
3140 /* ?get@istream@@QEAAAEAV1@AEAD@Z */
3141 DEFINE_THISCALL_WRAPPER(istream_get_char, 8)
3142 istream* __thiscall istream_get_char(istream *this, char *ch)
3143 {
3144     FIXME("(%p %p) stub\n", this, ch);
3145     return this;
3146 }
3147
3148 /* ?get@istream@@QAEAAV1@AAE@Z */
3149 /* ?get@istream@@QEAAAEAV1@AEAE@Z */
3150 DEFINE_THISCALL_WRAPPER(istream_get_unsigned_char, 8)
3151 istream* __thiscall istream_get_unsigned_char(istream *this, unsigned char *ch)
3152 {
3153     FIXME("(%p %p) stub\n", this, ch);
3154     return this;
3155 }
3156
3157 /* ?get@istream@@QAEHXZ */
3158 /* ?get@istream@@QEAAHXZ */
3159 DEFINE_THISCALL_WRAPPER(istream_get, 4)
3160 int __thiscall istream_get(istream *this)
3161 {
3162     FIXME("(%p) stub\n", this);
3163     return 0;
3164 }
3165
3166 /* ?get@istream@@QAEAAV1@AAVstreambuf@@D@Z */
3167 /* ?get@istream@@QEAAAEAV1@AEAVstreambuf@@D@Z */
3168 DEFINE_THISCALL_WRAPPER(istream_get_sb, 12)
3169 istream* __thiscall istream_get_sb(istream *this, streambuf *sb, char delim)
3170 {
3171     FIXME("(%p %p %c) stub\n", this, sb, delim);
3172     return this;
3173 }
3174
3175 /* ?getline@istream@@QAEAAV1@PACHD@Z */
3176 /* ?getline@istream@@QEAAAEAV1@PEACHD@Z */
3177 /* ?getline@istream@@QAEAAV1@PADHD@Z */
3178 /* ?getline@istream@@QEAAAEAV1@PEADHD@Z */
3179 DEFINE_THISCALL_WRAPPER(istream_getline, 16)
3180 istream* __thiscall istream_getline(istream *this, char *str, int count, char delim)
3181 {
3182     FIXME("(%p %p %d %c) stub\n", this, str, count, delim);
3183     return this;
3184 }
3185
3186 /* ?getline@istream@@QAEAAV1@PAEHD@Z */
3187 /* ?getline@istream@@QEAAAEAV1@PEAEHD@Z */
3188 DEFINE_THISCALL_WRAPPER(istream_getline_unsigned, 16)
3189 istream* __thiscall istream_getline_unsigned(istream *this, unsigned char *str, int count, char delim)
3190 {
3191     FIXME("(%p %p %d %c) stub\n", this, str, count, delim);
3192     return this;
3193 }
3194
3195 /* ?ignore@istream@@QAEAAV1@HH@Z */
3196 /* ?ignore@istream@@QEAAAEAV1@HH@Z */
3197 DEFINE_THISCALL_WRAPPER(istream_ignore, 12)
3198 istream* __thiscall istream_ignore(istream *this, int count, int delim)
3199 {
3200     FIXME("(%p %d %d) stub\n", this, count, delim);
3201     return this;
3202 }
3203
3204 /* ?peek@istream@@QAEHXZ */
3205 /* ?peek@istream@@QEAAHXZ */
3206 DEFINE_THISCALL_WRAPPER(istream_peek, 4)
3207 int __thiscall istream_peek(istream *this)
3208 {
3209     FIXME("(%p) stub\n", this);
3210     return 0;
3211 }
3212
3213 /* ?putback@istream@@QAEAAV1@D@Z */
3214 /* ?putback@istream@@QEAAAEAV1@D@Z */
3215 DEFINE_THISCALL_WRAPPER(istream_putback, 8)
3216 istream* __thiscall istream_putback(istream *this, char ch)
3217 {
3218     FIXME("(%p %c) stub\n", this, ch);
3219     return this;
3220 }
3221
3222 /* ?read@istream@@QAEAAV1@PACH@Z */
3223 /* ?read@istream@@QEAAAEAV1@PEACH@Z */
3224 /* ?read@istream@@QAEAAV1@PADH@Z */
3225 /* ?read@istream@@QEAAAEAV1@PEADH@Z */
3226 DEFINE_THISCALL_WRAPPER(istream_read, 12)
3227 istream* __thiscall istream_read(istream *this, char *str, int count)
3228 {
3229     FIXME("(%p %p %d) stub\n", this, str, count);
3230     return this;
3231 }
3232
3233 /* ?read@istream@@QAEAAV1@PAEH@Z */
3234 /* ?read@istream@@QEAAAEAV1@PEAEH@Z */
3235 DEFINE_THISCALL_WRAPPER(istream_read_unsigned, 12)
3236 istream* __thiscall istream_read_unsigned(istream *this, unsigned char *str, int count)
3237 {
3238     FIXME("(%p %p %d) stub\n", this, str, count);
3239     return this;
3240 }
3241
3242 /* ?seekg@istream@@QAEAAV1@J@Z */
3243 /* ?seekg@istream@@QEAAAEAV1@J@Z */
3244 DEFINE_THISCALL_WRAPPER(istream_seekg, 8)
3245 istream* __thiscall istream_seekg(istream *this, streampos pos)
3246 {
3247     FIXME("(%p %d) stub\n", this, pos);
3248     return this;
3249 }
3250
3251 /* ?seekg@istream@@QAEAAV1@JW4seek_dir@ios@@@Z */
3252 /* ?seekg@istream@@QEAAAEAV1@JW4seek_dir@ios@@@Z */
3253 DEFINE_THISCALL_WRAPPER(istream_seekg_offset, 12)
3254 istream* __thiscall istream_seekg_offset(istream *this, streamoff off, ios_seek_dir dir)
3255 {
3256     FIXME("(%p %d %d) stub\n", this, off, dir);
3257     return this;
3258 }
3259
3260 /* ?sync@istream@@QAEHXZ */
3261 /* ?sync@istream@@QEAAHXZ */
3262 DEFINE_THISCALL_WRAPPER(istream_sync, 4)
3263 int __thiscall istream_sync(istream *this)
3264 {
3265     FIXME("(%p) stub\n", this);
3266     return 0;
3267 }
3268
3269 /* ?tellg@istream@@QAEJXZ */
3270 /* ?tellg@istream@@QEAAJXZ */
3271 DEFINE_THISCALL_WRAPPER(istream_tellg, 4)
3272 streampos __thiscall istream_tellg(istream *this)
3273 {
3274     FIXME("(%p) stub\n", this);
3275     return 0;
3276 }
3277
3278 /* ?getint@istream@@AAEHPAD@Z */
3279 /* ?getint@istream@@AEAAHPEAD@Z */
3280 DEFINE_THISCALL_WRAPPER(istream_getint, 8)
3281 int __thiscall istream_getint(istream *this, char *str)
3282 {
3283     FIXME("(%p %p) stub\n", this, str);
3284     return 0;
3285 }
3286
3287 /* ?getdouble@istream@@AAEHPADH@Z */
3288 /* ?getdouble@istream@@AEAAHPEADH@Z */
3289 DEFINE_THISCALL_WRAPPER(istream_getdouble, 12)
3290 int __thiscall istream_getdouble(istream *this, char *str, int n)
3291 {
3292     FIXME("(%p %p %d) stub\n", this, str, n);
3293     return 0;
3294 }
3295
3296 /* ?ws@@YAAAVistream@@AAV1@@Z */
3297 /* ?ws@@YAAEAVistream@@AEAV1@@Z */
3298 istream* __cdecl istream_ws(istream *this)
3299 {
3300    FIXME("(%p) stub\n", this);
3301    return this;
3302 }
3303
3304 /******************************************************************
3305  *               ??0ostrstream@@QAE@XZ (MSVCRTI.@)
3306  */
3307 DEFINE_THISCALL_WRAPPER(MSVCIRT_ostrstream_ctor,8)
3308 void * __thiscall MSVCIRT_ostrstream_ctor(ostream *this, BOOL virt_init)
3309 {
3310    FIXME("(%p %x) stub\n", this, virt_init);
3311    return this;
3312 }
3313
3314 /******************************************************************
3315  *               ??1ostrstream@@UAE@XZ (MSVCRTI.@)
3316  */
3317 DEFINE_THISCALL_WRAPPER(MSVCIRT_ostrstream_dtor,4)
3318 void __thiscall MSVCIRT_ostrstream_dtor(ios *base)
3319 {
3320     FIXME("(%p) stub\n", base);
3321 }
3322
3323 #ifdef __i386__
3324
3325 #define DEFINE_VTBL_WRAPPER(off)            \
3326     __ASM_GLOBAL_FUNC(vtbl_wrapper_ ## off, \
3327         "popl %eax\n\t"                     \
3328         "popl %ecx\n\t"                     \
3329         "pushl %eax\n\t"                    \
3330         "movl 0(%ecx), %eax\n\t"            \
3331         "jmp *" #off "(%eax)\n\t")
3332
3333 DEFINE_VTBL_WRAPPER(0);
3334 DEFINE_VTBL_WRAPPER(4);
3335 DEFINE_VTBL_WRAPPER(8);
3336 DEFINE_VTBL_WRAPPER(12);
3337 DEFINE_VTBL_WRAPPER(16);
3338 DEFINE_VTBL_WRAPPER(20);
3339 DEFINE_VTBL_WRAPPER(24);
3340 DEFINE_VTBL_WRAPPER(28);
3341 DEFINE_VTBL_WRAPPER(32);
3342 DEFINE_VTBL_WRAPPER(36);
3343 DEFINE_VTBL_WRAPPER(40);
3344 DEFINE_VTBL_WRAPPER(44);
3345 DEFINE_VTBL_WRAPPER(48);
3346 DEFINE_VTBL_WRAPPER(52);
3347 DEFINE_VTBL_WRAPPER(56);
3348
3349 #endif
3350
3351 void* (__cdecl *MSVCRT_operator_new)(SIZE_T);
3352 void (__cdecl *MSVCRT_operator_delete)(void*);
3353
3354 static void init_cxx_funcs(void)
3355 {
3356     HMODULE hmod = GetModuleHandleA("msvcrt.dll");
3357
3358     if (sizeof(void *) > sizeof(int))  /* 64-bit has different names */
3359     {
3360         MSVCRT_operator_new = (void*)GetProcAddress(hmod, "??2@YAPEAX_K@Z");
3361         MSVCRT_operator_delete = (void*)GetProcAddress(hmod, "??3@YAXPEAX@Z");
3362     }
3363     else
3364     {
3365         MSVCRT_operator_new = (void*)GetProcAddress(hmod, "??2@YAPAXI@Z");
3366         MSVCRT_operator_delete = (void*)GetProcAddress(hmod, "??3@YAXPAX@Z");
3367     }
3368 }
3369
3370 static void init_io(void *base)
3371 {
3372 #ifdef __x86_64__
3373     init_streambuf_rtti(base);
3374     init_filebuf_rtti(base);
3375     init_strstreambuf_rtti(base);
3376     init_stdiobuf_rtti(base);
3377     init_ios_rtti(base);
3378     init_ostream_rtti(base);
3379     init_istream_rtti(base);
3380 #endif
3381 }
3382
3383 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
3384 {
3385    switch (reason)
3386    {
3387    case DLL_WINE_PREATTACH:
3388        return FALSE;  /* prefer native version */
3389    case DLL_PROCESS_ATTACH:
3390        init_cxx_funcs();
3391        init_exception(inst);
3392        init_io(inst);
3393        DisableThreadLibraryCalls( inst );
3394        break;
3395    }
3396    return TRUE;
3397 }