自学教程：C++ HeapReAlloc函数代码示例

static struct output *add_output( struct d3dadapter9 *This ){    struct adapter_group *group = &This->groups[This->ngroups-1];    if (group->noutputs >= group->noutputsalloc) {        void *r;        if (group->noutputsalloc == 0) {            group->noutputsalloc = 2;            r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,                          group->noutputsalloc*sizeof(struct output));        } else {            group->noutputsalloc <<= 1;            r = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, group->outputs,                            group->noutputsalloc*sizeof(struct output));        }        if (!r) { return NULL; }        group->outputs = r;    }    return &group->outputs[group->noutputs++];}

/* Renderbuffer routines */static GLbooleansw_bb_renderbuffer_storage(struct gl_context* ctx, struct gl_renderbuffer *rb,                          GLenum internalFormat,                          GLuint width, GLuint height){    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);    struct sw_framebuffer* fb = CONTAINING_RECORD(srb, struct sw_framebuffer, backbuffer);    UINT widthBytes = WIDTH_BYTES_ALIGN32(width, pixel_formats[fb->format_index].color_bits);     srb->Base.Format = pixel_formats[fb->format_index].mesa;    if(srb->Buffer)        srb->Buffer = HeapReAlloc(GetProcessHeap(), 0, srb->Buffer, widthBytes*height);    else        srb->Buffer = HeapAlloc(GetProcessHeap(), 0, widthBytes*height);    if(!srb->Buffer)    {        srb->Base.Format = MESA_FORMAT_NONE;        return GL_FALSE;    }    srb->Base.Width = width;    srb->Base.Height = height;    srb->RowStride = widthBytes;    return GL_TRUE;}

void clsGlobalDataQueue::AddDataToQueue(GlobalQueue &pQueue, char * sData, const size_t &szLen) {    if(pQueue.szSize < (pQueue.szLen + szLen)) {        size_t szAllignLen = Allign256(pQueue.szLen + szLen);        char * pOldBuf = pQueue.sBuffer;#ifdef _WIN32        pQueue.sBuffer = (char *)HeapReAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, szAllignLen);#else		pQueue.sBuffer = (char *)realloc(pOldBuf, szAllignLen);#endif        if(pQueue.sBuffer == NULL) {            pQueue.sBuffer = pOldBuf;            AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in clsGlobalDataQueue::AddDataToQueue/n", (uint64_t)szAllignLen);            return;        }        pQueue.szSize = szAllignLen-1;    }    memcpy(pQueue.sBuffer+pQueue.szLen, sData, szLen);    pQueue.szLen += szLen;    pQueue.sBuffer[pQueue.szLen] = '/0';}

/* prepare the text mode video memory copy that is used to only * update the video memory line that did get updated. */static void VGA_PrepareVideoMemCopy(unsigned Xres, unsigned Yres){    char *p, *p2;    unsigned int i;    /*     * Allocate space for char + attr.     */    if (vga_text_old)        vga_text_old = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,                                 vga_text_old, Xres * Yres * 2 );    else        vga_text_old = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,                                  Xres * Yres * 2 );    p = VGA_AlphaBuffer();    p2 = vga_text_old;    /* make sure the video mem copy contains the exact opposite of our     * actual text mode memory area to make sure the screen     * does get updated fully initially */    for (i=0; i < Xres*Yres*2; i++)	*p2++ = *p++ ^ 0xff; /* XOR it */}

// appends data to the UserIPQueuevoid clsGlobalDataQueue::UserIPStore(User * pUser) {    if(UserIPQueue.szLen == 0) {        UserIPQueue.szLen = sprintf(UserIPQueue.sBuffer, "$UserIP %s %s|", pUser->sNick, pUser->sIP);        UserIPQueue.bHaveDollars = false;    } else {        int iDataLen = sprintf(msg, "%s %s$$|", pUser->sNick, pUser->sIP);        if(CheckSprintf(iDataLen, 128, "clsGlobalDataQueue::UserIPStore") == true) {            if(UserIPQueue.bHaveDollars == false) {                UserIPQueue.sBuffer[UserIPQueue.szLen-1] = '$';                UserIPQueue.sBuffer[UserIPQueue.szLen] = '$';                UserIPQueue.bHaveDollars = true;                UserIPQueue.szLen += 2;            }            if(UserIPQueue.szSize < UserIPQueue.szLen+iDataLen) {                size_t szAllignLen = Allign256(UserIPQueue.szLen+iDataLen);                char * pOldBuf = UserIPQueue.sBuffer;#ifdef _WIN32                UserIPQueue.sBuffer = (char *)HeapReAlloc(clsServerManager::hLibHeap, HEAP_NO_SERIALIZE, (void *)pOldBuf, szAllignLen);#else				UserIPQueue.sBuffer = (char *)realloc(pOldBuf, szAllignLen);#endif                if(UserIPQueue.sBuffer == NULL) {                    UserIPQueue.sBuffer = pOldBuf;					AppendDebugLog("%s - [MEM] Cannot reallocate %" PRIu64 " bytes in clsGlobalDataQueue::UserIPStore/n", (uint64_t)szAllignLen);                    return;                }                UserIPQueue.szSize = (uint32_t)(szAllignLen-1);            }            memcpy(UserIPQueue.sBuffer+UserIPQueue.szLen-1, msg, iDataLen);            UserIPQueue.szLen += iDataLen-1;            UserIPQueue.sBuffer[UserIPQueue.szLen] = '/0';        }    }}

/* Helper for GDI_Bezier. * Just handles one Bezier, so Points should point to four POINTs */static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,				INT *nPtsOut, INT level ){    if(*nPtsOut == *dwOut) {        *dwOut *= 2;	*PtsOut = HeapReAlloc( GetProcessHeap(), 0, *PtsOut,			       *dwOut * sizeof(POINT) );    }    if(!level || BezierCheck(level, Points)) {        if(*nPtsOut == 0) {            (*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x);            (*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y);            *nPtsOut = 1;        }	(*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x);        (*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y);        (*nPtsOut) ++;    } else {        POINT Points2[4]; /* for the second recursive call */        Points2[3]=Points[3];        BEZIERMIDDLE(Points2[2], Points[2], Points[3]);        BEZIERMIDDLE(Points2[0], Points[1], Points[2]);        BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);        BEZIERMIDDLE(Points[1], Points[0],  Points[1]);        BEZIERMIDDLE(Points[2], Points[1], Points2[0]);        BEZIERMIDDLE(Points[3], Points[2], Points2[1]);        Points2[0]=Points[3];        /* do the two halves */        GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1);        GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1);    }}

static BOOL fetch_process_thread( DWORD flags, SYSTEM_PROCESS_INFORMATION** pspi,                                  ULONG* num_pcs, ULONG* num_thd){    NTSTATUS                    status;    ULONG                       size, offset;    PSYSTEM_PROCESS_INFORMATION spi;    *num_pcs = *num_thd = 0;    if (!(flags & (TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD))) return TRUE;    *pspi = HeapAlloc( GetProcessHeap(), 0, size = 4096 );    for (;;)    {        status = NtQuerySystemInformation( SystemProcessInformation, *pspi,                                           size, NULL );        switch (status)        {        case STATUS_SUCCESS:            *num_pcs = *num_thd = offset = 0;            spi = *pspi;            do            {                spi = (SYSTEM_PROCESS_INFORMATION*)((char*)spi + offset);                if (flags & TH32CS_SNAPPROCESS) (*num_pcs)++;                if (flags & TH32CS_SNAPTHREAD) *num_thd += spi->dwThreadCount;            } while ((offset = spi->NextEntryOffset));            return TRUE;        case STATUS_INFO_LENGTH_MISMATCH:            *pspi = HeapReAlloc( GetProcessHeap(), 0, *pspi, size *= 2 );            break;        default:            SetLastError( RtlNtStatusToDosError( status ) );            break;        }    }}

LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize){    return HeapReAlloc(GetProcessHeap(), 0, pv, cbSize);}

//.........这里部分代码省略.........    device->pwfx = DSOUND_CopyFormat(wfex);    if ( device->pwfx == NULL )	return DSERR_OUTOFMEMORY;    This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,        sizeof(IDirectSoundCaptureBufferImpl));    if ( This == NULL ) {	WARN("out of memory/n");	return DSERR_OUTOFMEMORY;    } else {        HRESULT err = DS_OK;        LPBYTE newbuf;        DWORD buflen;        This->numIfaces = 0;        This->ref = 0;        This->refn = 0;        This->device = device;        This->device->capture_buffer = This;        This->nrofnotifies = 0;        This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,            lpcDSCBufferDesc->dwSize);        if (This->pdscbd)            CopyMemory(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);        else {            WARN("no memory/n");            This->device->capture_buffer = 0;            HeapFree( GetProcessHeap(), 0, This );            return DSERR_OUTOFMEMORY;        }        This->IDirectSoundCaptureBuffer8_iface.lpVtbl = &dscbvt;        This->IDirectSoundNotify_iface.lpVtbl = &dscnvt;        err = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,                CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);        if(FAILED(err)){            WARN("Activate failed: %08x/n", err);            HeapFree(GetProcessHeap(), 0, This->pdscbd);            This->device->capture_buffer = 0;            HeapFree( GetProcessHeap(), 0, This );            return err;        }        err = IAudioClient_Initialize(device->client,                AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST,                200 * 100000, 50000, device->pwfx, NULL);        if(FAILED(err)){            WARN("Initialize failed: %08x/n", err);            IAudioClient_Release(device->client);            device->client = NULL;            HeapFree(GetProcessHeap(), 0, This->pdscbd);            This->device->capture_buffer = 0;            HeapFree( GetProcessHeap(), 0, This );            if(err == AUDCLNT_E_UNSUPPORTED_FORMAT)                return DSERR_BADFORMAT;            return err;        }        err = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,                (void**)&device->capture);        if(FAILED(err)){            WARN("GetService failed: %08x/n", err);            IAudioClient_Release(device->client);            device->client = NULL;            HeapFree(GetProcessHeap(), 0, This->pdscbd);            This->device->capture_buffer = 0;            HeapFree( GetProcessHeap(), 0, This );            return err;        }        buflen = lpcDSCBufferDesc->dwBufferBytes;        TRACE("desired buflen=%d, old buffer=%p/n", buflen, device->buffer);        if (device->buffer)            newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);        else            newbuf = HeapAlloc(GetProcessHeap(),0,buflen);        if (newbuf == NULL) {            IAudioClient_Release(device->client);            device->client = NULL;            IAudioCaptureClient_Release(device->capture);            device->capture = NULL;            HeapFree(GetProcessHeap(), 0, This->pdscbd);            This->device->capture_buffer = 0;            HeapFree( GetProcessHeap(), 0, This );            return DSERR_OUTOFMEMORY;        }        device->buffer = newbuf;        device->buflen = buflen;    }    IDirectSoundCaptureBuffer_AddRef(&This->IDirectSoundCaptureBuffer8_iface);    *ppobj = This;    TRACE("returning DS_OK/n");    return DS_OK;}

void* yr_realloc(void* ptr, size_t size){  return (void*) HeapReAlloc(hHeap, HEAP_ZERO_MEMORY, ptr, size);}

static INT find_joystick_devices(void){    INT i;    if (joystick_devices_count != -1) return joystick_devices_count;    joystick_devices_count = 0;    for (i = 0; i < MAX_JOYSTICKS; i++)    {        int fd;        struct JoyDev joydev, *new_joydevs;        BYTE axes_map[ABS_MAX + 1];        snprintf(joydev.device, sizeof(joydev.device), "%s%d", JOYDEV_NEW, i);        if ((fd = open(joydev.device, O_RDONLY)) < 0)        {            snprintf(joydev.device, sizeof(joydev.device), "%s%d", JOYDEV_OLD, i);            if ((fd = open(joydev.device, O_RDONLY)) < 0) continue;        }        strcpy(joydev.name, "Wine Joystick");#if defined(JSIOCGNAME)        if (ioctl(fd, JSIOCGNAME(sizeof(joydev.name) - sizeof(JOYDEVDRIVER)), joydev.name) < 0)            WARN("ioctl(%s,JSIOCGNAME) failed: %s/n", joydev.device, strerror(errno));#endif        /* Append driver name */        strcat(joydev.name, JOYDEVDRIVER);        if (device_disabled_registry(joydev.name)) {            close(fd);            continue;        }#ifdef JSIOCGAXES        if (ioctl(fd, JSIOCGAXES, &joydev.axis_count) < 0)        {            WARN("ioctl(%s,JSIOCGAXES) failed: %s, defauting to 2/n", joydev.device, strerror(errno));            joydev.axis_count = 2;        }#endif#ifdef JSIOCGBUTTONS        if (ioctl(fd, JSIOCGBUTTONS, &joydev.button_count) < 0)        {            WARN("ioctl(%s,JSIOCGBUTTONS) failed: %s, defauting to 2/n", joydev.device, strerror(errno));            joydev.button_count = 2;        }#endif        if (ioctl(fd, JSIOCGAXMAP, axes_map) < 0)        {            WARN("ioctl(%s,JSIOCGNAME) failed: %s/n", joydev.device, strerror(errno));            joydev.dev_axes_map = NULL;        }        else            if ((joydev.dev_axes_map = HeapAlloc(GetProcessHeap(), 0, joydev.axis_count * sizeof(int))))            {                INT j;                /* Remap to DI numbers */                for (j = 0; j < joydev.axis_count; j++)                    if (axes_map[j] < 8)                        /* Axis match 1-to-1 */                        joydev.dev_axes_map[j] = j;                    else if (axes_map[j] == 16 ||                             axes_map[j] == 17)                        /* POV axis */                        joydev.dev_axes_map[j] = 8;                    else                        joydev.dev_axes_map[j] = -1;            }        close(fd);        if (!joystick_devices_count)            new_joydevs = HeapAlloc(GetProcessHeap(), 0, sizeof(struct JoyDev));        else            new_joydevs = HeapReAlloc(GetProcessHeap(), 0, joystick_devices,                                      (joystick_devices_count + 1) * sizeof(struct JoyDev));        if (!new_joydevs) continue;        TRACE("Found a joystick on %s: %s/n  with %d axes and %d buttons/n", joydev.device,              joydev.name, joydev.axis_count, joydev.button_count);        joystick_devices = new_joydevs;        joystick_devices[joystick_devices_count++] = joydev;    }    return joystick_devices_count;}

static void processRegLinesW(FILE *in){    WCHAR* buf           = NULL;  /* line read from input stream */    ULONG lineSize       = REG_VAL_BUF_SIZE;    size_t CharsInBuf = -1;    WCHAR* s; /* The pointer into buf for where the current fgets should read */    WCHAR* line; /* The start of the current line */    buf = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(WCHAR));    CHECK_ENOUGH_MEMORY(buf);    s = buf;    line = buf;    while(!feof(in)) {        size_t size_remaining;        int size_to_get;        WCHAR *s_eol = NULL; /* various local uses */        /* Do we need to expand the buffer ? */        assert (s >= buf && s <= buf + lineSize);        size_remaining = lineSize - (s-buf);        if (size_remaining < 2) /* room for 1 character and the /0 */        {            WCHAR *new_buffer;            size_t new_size = lineSize + (REG_VAL_BUF_SIZE / sizeof(WCHAR));            if (new_size > lineSize) /* no arithmetic overflow */                new_buffer = HeapReAlloc (GetProcessHeap(), 0, buf, new_size * sizeof(WCHAR));            else                new_buffer = NULL;            CHECK_ENOUGH_MEMORY(new_buffer);            buf = new_buffer;            line = buf;            s = buf + lineSize - size_remaining;            lineSize = new_size;            size_remaining = lineSize - (s-buf);        }        /* Get as much as possible into the buffer, terminated either by        * eof, error or getting the maximum amount.  Abort on error.        */        size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);        CharsInBuf = fread(s, sizeof(WCHAR), size_to_get - 1, in);        s[CharsInBuf] = 0;        if (CharsInBuf == 0) {            if (ferror(in)) {                perror ("While reading input");                exit (IO_ERROR);            } else {                assert (feof(in));                *s = '/0';                /* It is not clear to me from the definition that the                * contents of the buffer are well defined on detecting                * an eof without managing to read anything.                */            }        }        /* If we didn't read the eol nor the eof go around for the rest */        while(1)        {            const WCHAR line_endings[] = {'/r','/n',0};            s_eol = strpbrkW(line, line_endings);            if(!s_eol) {                /* Move the stub of the line to the start of the buffer so                 * we get the maximum space to read into, and so we don't                 * have to recalculate 'line' if the buffer expands */                MoveMemory(buf, line, (strlenW(line)+1) * sizeof(WCHAR));                line = buf;                s = strchrW(line, '/0');                break;            }            /* If it is a comment line then discard it and go around again */            if (*line == '#' || *line == ';') {                if (*s_eol == '/r' && *(s_eol+1) == '/n')                    line = s_eol + 2;                else                    line = s_eol + 1;                continue;            }            /* If there is a concatenating // then go around again */            if (*(s_eol-1) == '//') {                WCHAR* NextLine = s_eol + 1;                if(*s_eol == '/r' && *(s_eol+1) == '/n')                    NextLine++;                while(*(NextLine+1) == ' ' || *(NextLine+1) == '/t')                    NextLine++;                MoveMemory(s_eol - 1, NextLine, (CharsInBuf - (NextLine - s) + 1)*sizeof(WCHAR));                CharsInBuf -= NextLine - s_eol + 1;                s_eol = 0;                continue;//.........这里部分代码省略.........

void * __cdecl realloc(_Post_ptr_invalid_ void * _Memory, _In_ size_t _NewSize){	return HeapReAlloc(GetProcessHeap(), 0, _Memory, _NewSize);}

//.........这里部分代码省略.........	if(t42->tables[i].write) t42->num_of_written_tables++;	if(t42->tables[i].MS_tag == MS_MAKE_TAG('l','o','c','a'))	    t42->loca_tab = i;	else if(t42->tables[i].MS_tag == MS_MAKE_TAG('g','l','y','f'))	    t42->glyf_tab = i;	else if(t42->tables[i].MS_tag == MS_MAKE_TAG('h','e','a','d'))	    t42->head_tab = i;	else if(t42->tables[i].MS_tag == MS_MAKE_TAG('h','m','t','x'))	    t42->hmtx_tab = i;	else if(t42->tables[i].MS_tag == MS_MAKE_TAG('m','a','x','p'))	    t42->maxp_tab = i;    }    if(i < num_of_tables) {        TRACE("Table %d has length %d.  Will use Type 1 font instead./n", i, t42->tables[i].len);        T42_free(t42);	return NULL;    }    t42->glyph_sent_size = GLYPH_SENT_INC;    t42->glyph_sent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,				t42->glyph_sent_size *				sizeof(*(t42->glyph_sent)));    buf = HeapAlloc(GetProcessHeap(), 0, sizeof(start) + strlen(ps_name) +		    100);    push_lc_numeric("C");    sprintf(buf, start, ps_name,	    (float)bbox->left / emsize, (float)bbox->bottom / emsize,	    (float)bbox->right / emsize, (float)bbox->top / emsize);    pop_lc_numeric();    PSDRV_WriteSpool(physDev, buf, strlen(buf));    t42->num_of_written_tables++; /* explicitly add glyf */    sprintf(buf, TT_offset_table, t42->num_of_written_tables,	    t42->num_of_written_tables, t42->num_of_written_tables, t42->num_of_written_tables);    PSDRV_WriteSpool(physDev, buf, strlen(buf));    tablepos = 12 + t42->num_of_written_tables * 16;    cur_off = 12;    for(i = 0; i < num_of_tables; i++) {        if(!t42->tables[i].write) continue;        sprintf(buf, TT_table_dir_entry, FLIP_ORDER(t42->tables[i].MS_tag),		t42->tables[i].check, t42->tables[i].len ? tablepos : 0,		t42->tables[i].len);	PSDRV_WriteSpool(physDev, buf, strlen(buf));	tablepos += ((t42->tables[i].len + 3) & ~3);        if(t42->tables[i].MS_tag == MS_MAKE_TAG('l','o','c','a'))            loca_off = cur_off;        cur_off += 16;    }    sprintf(buf, TT_table_dir_entry, FLIP_ORDER(t42->tables[t42->glyf_tab].MS_tag),            t42->tables[t42->glyf_tab].check, tablepos, t42->tables[t42->glyf_tab].len);    PSDRV_WriteSpool(physDev, buf, strlen(buf));    PSDRV_WriteSpool(physDev, "00>/n", 4); /* add an extra byte for old PostScript rips */    glyf_off = cur_off;    for(i = 0; i < num_of_tables; i++) {        if(t42->tables[i].len == 0 || !t42->tables[i].write) continue;	PSDRV_WriteSpool(physDev, "<", 1);	for(j = 0; j < ((t42->tables[i].len + 3) & ~3); j++) {	    sprintf(buf, "%02x", t42->tables[i].data[j]);	    PSDRV_WriteSpool(physDev, buf, strlen(buf));	    if(j % 16 == 15) PSDRV_WriteSpool(physDev, "/n", 1);	}	PSDRV_WriteSpool(physDev, "00>/n", 4); /* add an extra byte for old PostScript rips */    }        /* glyf_blocks is a 0 terminated list, holding the start offset of each block.  For simplicity       glyf_blocks[0] is 0 */    nb_blocks = 2;    t42->glyf_blocks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nb_blocks + 1) * sizeof(DWORD));    for(i = 0; i < GET_BE_WORD(t42->tables[t42->maxp_tab].data + 4); i++) {        DWORD start, end, size;        get_glyf_pos(t42, i, &start, &end);        size = end - t42->glyf_blocks[nb_blocks-2];        if(size > 0x2000 && t42->glyf_blocks[nb_blocks-1] % 4 == 0) {            nb_blocks++;            t42->glyf_blocks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,                                           t42->glyf_blocks, (nb_blocks + 1) * sizeof(DWORD));        }        t42->glyf_blocks[nb_blocks-1] = end;    }    PSDRV_WriteSpool(physDev, "[ ", 2);    for(i = 1; t42->glyf_blocks[i]; i++) {        sprintf(buf,"%d ", t42->glyf_blocks[i] - t42->glyf_blocks[i-1] + 1);        /* again add one byte for old PostScript rips */        PSDRV_WriteSpool(physDev, buf, strlen(buf));        if(i % 8 == 0)            PSDRV_WriteSpool(physDev, "/n", 1);    }    PSDRV_WriteSpool(physDev, storage, sizeof(storage) - 1);    sprintf(buf, end, loca_off, glyf_off);    PSDRV_WriteSpool(physDev, buf, strlen(buf));    HeapFree(GetProcessHeap(), 0, buf);    return t42;}

static HRESULT ID3DXFileDataImpl_Create(IDirectXFileObject *dxfile_object, ID3DXFileData **ret_iface){    ID3DXFileDataImpl *object;    IDirectXFileObject *data_object;    HRESULT ret;    TRACE("(%p, %p)/n", dxfile_object, ret_iface);    *ret_iface = NULL;    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));    if (!object)        return E_OUTOFMEMORY;    object->ID3DXFileData_iface.lpVtbl = &ID3DXFileData_Vtbl;    object->ref = 1;    ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileData, (void **)&object->dxfile_data);    if (FAILED(ret))    {        IDirectXFileDataReference *reference;        ret = IDirectXFileObject_QueryInterface(dxfile_object, &IID_IDirectXFileDataReference, (void **)&reference);        if (SUCCEEDED(ret))        {            ret = IDirectXFileDataReference_Resolve(reference, &object->dxfile_data);            if (FAILED(ret))            {                HeapFree(GetProcessHeap(), 0, object);                return E_FAIL;            }            object->reference = TRUE;        }        else        {            FIXME("Don't known what to do with binary object/n");            HeapFree(GetProcessHeap(), 0, object);            return E_FAIL;        }    }    while (SUCCEEDED(ret = IDirectXFileData_GetNextObject(object->dxfile_data, &data_object)))    {        if (object->children)            object->children = HeapReAlloc(GetProcessHeap(), 0, object->children, sizeof(ID3DXFileData*) * (object->nb_children + 1));        else            object->children = HeapAlloc(GetProcessHeap(), 0, sizeof(ID3DXFileData*));        if (!object->children)        {            ret = E_OUTOFMEMORY;            break;        }        ret = ID3DXFileDataImpl_Create(data_object, &object->children[object->nb_children]);        if (ret != S_OK)            break;        object->nb_children++;    }    if (ret != DXFILEERR_NOMOREOBJECTS)    {        (&object->ID3DXFileData_iface)->lpVtbl->Release(&object->ID3DXFileData_iface);        return ret;    }    TRACE("Found %u children/n", object->nb_children);    *ret_iface = &object->ID3DXFileData_iface;    return S_OK;}

static HRESULT WINAPI ID3DXFileImpl_CreateEnumObject(ID3DXFile *iface, const void *source, D3DXF_FILELOADOPTIONS options, ID3DXFileEnumObject **enum_object){    ID3DXFileImpl *This = impl_from_ID3DXFile(iface);    ID3DXFileEnumObjectImpl *object;    IDirectXFileEnumObject *dxfile_enum_object;    void *dxfile_source;    DXFILELOADOPTIONS dxfile_options;    DXFILELOADRESOURCE dxfile_resource;    DXFILELOADMEMORY dxfile_memory;    IDirectXFileData *data_object;    HRESULT ret;    TRACE("(%p)->(%p, %x, %p)/n", iface, source, options, enum_object);    if (!enum_object)        return E_POINTER;    *enum_object = NULL;    if (options == D3DXF_FILELOAD_FROMFILE)    {        dxfile_source = (void*)source;        dxfile_options = DXFILELOAD_FROMFILE;    }    else if (options == D3DXF_FILELOAD_FROMRESOURCE)    {        D3DXF_FILELOADRESOURCE *resource = (D3DXF_FILELOADRESOURCE*)source;        dxfile_resource.hModule = resource->hModule;        dxfile_resource.lpName = resource->lpName;        dxfile_resource.lpType = resource->lpType;        dxfile_source = &dxfile_resource;        dxfile_options = DXFILELOAD_FROMRESOURCE;    }    else if (options == D3DXF_FILELOAD_FROMMEMORY)    {        D3DXF_FILELOADMEMORY *memory = (D3DXF_FILELOADMEMORY*)source;        dxfile_memory.lpMemory = memory->lpMemory;        dxfile_memory.dSize = memory->dSize;        dxfile_source = &dxfile_memory;        dxfile_options = DXFILELOAD_FROMMEMORY;    }    else    {        FIXME("Source type %u is not handled yet/n", options);        return E_NOTIMPL;    }    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));    if (!object)        return E_OUTOFMEMORY;    object->ID3DXFileEnumObject_iface.lpVtbl = &ID3DXFileEnumObject_Vtbl;    object->ref = 1;    ret = IDirectXFile_CreateEnumObject(This->dxfile, dxfile_source, dxfile_options, &dxfile_enum_object);    if (ret != S_OK)    {        HeapFree(GetProcessHeap(), 0, object);        return ret;    }    /* Fill enum object with top level data objects */    while (SUCCEEDED(ret = IDirectXFileEnumObject_GetNextDataObject(dxfile_enum_object, &data_object)))    {        if (object->children)            object->children = HeapReAlloc(GetProcessHeap(), 0, object->children, sizeof(*object->children) * (object->nb_children + 1));        else            object->children = HeapAlloc(GetProcessHeap(), 0, sizeof(*object->children));        if (!object->children)        {            ret = E_OUTOFMEMORY;            break;        }        ret = ID3DXFileDataImpl_Create((IDirectXFileObject*)data_object, &object->children[object->nb_children]);        if (ret != S_OK)            break;        object->nb_children++;    }    IDirectXFileEnumObject_Release(dxfile_enum_object);    if (ret != DXFILEERR_NOMOREOBJECTS)        WARN("Cannot get all top level data objects/n");    TRACE("Found %u children/n", object->nb_children);    *enum_object = &object->ID3DXFileEnumObject_iface;    return S_OK;}

BOOL T42_download_glyph(PSDRV_PDEVICE *physDev, DOWNLOAD *pdl, DWORD index,			char *glyph_name){    DWORD start, end, i;    char *buf;    TYPE42 *t42;    const char glyph_def[] =       "/%s findfont exch 1 index/n"      "havetype42gdir/n"      "{/GlyphDirectory get begin %d exch def end}/n"      "{/sfnts get 4 index get 3 index 2 index putinterval pop}/n"      "ifelse/n"      "/CharStrings get/n"      "begin/n"      " /%s %d def/n"      "end/n"      "pop pop/n";    TRACE("%d %s/n", index, glyph_name);    assert(pdl->type == Type42);    t42 = pdl->typeinfo.Type42;    if(index < t42->glyph_sent_size) {        if(t42->glyph_sent[index])	    return TRUE;    } else {        t42->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC;	t42->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,				      t42->glyph_sent,				      t42->glyph_sent_size * sizeof(*(t42->glyph_sent)));    }    if(!get_glyf_pos(t42, index, &start, &end)) return FALSE;    TRACE("start = %x end = %x/n", start, end);    if(GET_BE_WORD(t42->tables[t42->glyf_tab].data + start) == 0xffff) {      /* Composite glyph */        BYTE *sg_start = t42->tables[t42->glyf_tab].data + start + 10;	DWORD sg_flags, sg_index;	char sg_name[MAX_G_NAME + 1];	do {	    sg_flags = GET_BE_WORD(sg_start);	    sg_index = GET_BE_WORD(sg_start + 2);	    TRACE("Sending subglyph %04x for glyph %04x/n", sg_index, index);	    get_glyph_name(physDev->hdc, sg_index, sg_name);	    T42_download_glyph(physDev, pdl, sg_index, sg_name);	    sg_start += 4;	    if(sg_flags & ARG_1_AND_2_ARE_WORDS)	        sg_start += 4;	    else	        sg_start += 2;	    if(sg_flags & WE_HAVE_A_SCALE)	        sg_start += 2;	    else if(sg_flags & WE_HAVE_AN_X_AND_Y_SCALE)	        sg_start += 4;	    else if(sg_flags & WE_HAVE_A_TWO_BY_TWO)	        sg_start += 8;	} while(sg_flags & MORE_COMPONENTS);    }    for(i = 1; t42->glyf_blocks[i]; i++)        if(start < t42->glyf_blocks[i]) break;    buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def) +		    strlen(pdl->ps_name) + 100);    /* we don't have a string for the gdir and glyf tables, but we do have a        string for the TT header.  So the offset we need is tables - 2 */    sprintf(buf, "%d %d/n", t42->num_of_written_tables - 2 + i, start - t42->glyf_blocks[i-1]);    PSDRV_WriteSpool(physDev, buf, strlen(buf));    PSDRV_WriteSpool(physDev, "<", 1);    for(i = start; i < end; i++) {        sprintf(buf, "%02x", *(t42->tables[t42->glyf_tab].data + i));	PSDRV_WriteSpool(physDev, buf, strlen(buf));	if((i - start) % 16 == 15)	    PSDRV_WriteSpool(physDev, "/n", 1);    }    PSDRV_WriteSpool(physDev, ">/n", 2);    sprintf(buf, glyph_def, pdl->ps_name, index, glyph_name, index);    PSDRV_WriteSpool(physDev, buf, strlen(buf));    t42->glyph_sent[index] = TRUE;    HeapFree(GetProcessHeap(), 0, buf);    return TRUE;}

/****************************************************************************** * Processes a registry file. * Correctly processes comments (in # and ; form), line continuation. * * Parameters: *   in - input stream to read from *   first_chars - beginning of stream, read due to Unicode check */static void processRegLinesA(FILE *in, char* first_chars){    LPSTR line           = NULL;  /* line read from input stream */    ULONG lineSize       = REG_VAL_BUF_SIZE;    line = HeapAlloc(GetProcessHeap(), 0, lineSize);    CHECK_ENOUGH_MEMORY(line);    memcpy(line, first_chars, 2);    while (!feof(in)) {        LPSTR s; /* The pointer into line for where the current fgets should read */        WCHAR* lineW;        s = line;        if(first_chars)        {            s += 2;            first_chars = NULL;        }        for (;;) {            size_t size_remaining;            int size_to_get, i;            char *s_eol; /* various local uses */            /* Do we need to expand the buffer ? */            assert (s >= line && s <= line + lineSize);            size_remaining = lineSize - (s-line);            if (size_remaining < 2) /* room for 1 character and the /0 */            {                char *new_buffer;                size_t new_size = lineSize + REG_VAL_BUF_SIZE;                if (new_size > lineSize) /* no arithmetic overflow */                    new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size);                else                    new_buffer = NULL;                CHECK_ENOUGH_MEMORY(new_buffer);                line = new_buffer;                s = line + lineSize - size_remaining;                lineSize = new_size;                size_remaining = lineSize - (s-line);            }            /* Get as much as possible into the buffer, terminated either by             * eof, error, eol or getting the maximum amount.  Abort on error.             */            size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);            /* get a single line. note that `i' must be one past the last             * meaningful character in `s' when this loop exits */            for(i = 0; i < size_to_get-1; ++i){                int xchar;                xchar = fgetc(in);                s[i] = xchar;                if(xchar == EOF){                    if(ferror(in)){                        perror("While reading input");                        exit(IO_ERROR);                    }else                        assert(feof(in));                    break;                }                if(s[i] == '/r'){                    /* read the next character iff it's /n */                    if(i+2 >= size_to_get){                        /* buffer too short, so put back the EOL char to                         * read next cycle */                        ungetc('/r', in);                        break;                    }                    s[i+1] = fgetc(in);                    if(s[i+1] != '/n'){                        ungetc(s[i+1], in);                        i = i+1;                    }else                        i = i+2;                    break;                }                if(s[i] == '/n'){                    i = i+1;                    break;                }            }            s[i] = '/0';            /* If we didn't read the eol nor the eof go around for the rest */            s_eol = strpbrk (s, "/r/n");            if (!feof (in) && !s_eol) {                s = strchr (s, '/0');                continue;            }//.........这里部分代码省略.........

intODBCStringsMatrix::LoadFromRst(CODBCRecordset* pRst, int nDataId, int* pStringIds, int nCount)	{	FreeStringsArray();	if( !pRst->IsBOF() )		pRst->MoveFirst();	m_nColFields		= nCount;const int	nHeapBlock	= 2048;	long	lData		= 0;	int		nLoop		= 0, nIndex = 0, nItem = 0, nAddSize;	int		nSize		= 0, nSizeOffsets = (nCount + 1)*sizeof(int);	WORD*	pStrOffsets	= new WORD[nCount*2]; // (WORD)[start offset](WORD)[end offset].	// Create and allocate heap. ####################	if( !m_hHeap )		{		m_hHeap				= HeapCreate(0L, nHeapBlock, 0L);		ASSERT( m_hHeap );		m_pBuffer			= (BYTE*)HeapAlloc(m_hHeap, 0L, nHeapBlock);		m_nHeapAllocSize	= nHeapBlock;		m_nHeapUsedSize		= 0;		}	else		m_nHeapUsedSize		= 0;	// ###############################################	// Fill full strings array. ##################	CString sValue;	while( !pRst->IsEOF() )		{		int nLoop1		= 2;		lData			= pRst->GetLong(nDataId);		// Load field strings and build offsets array.		sValue			= pRst->GetString(pStringIds[0]);		pStrOffsets[2]	= 0;		pStrOffsets[3]	= (WORD)sValue.GetLength();		while( nLoop1 <= nCount )			{			pStrOffsets[nLoop1*2]		= pStrOffsets[nLoop1*2 - 1] + 1;			sValue	+= _T(" ");			sValue	+= pRst->GetString(pStringIds[nLoop1 - 1]);			pStrOffsets[nLoop1*2 + 1]	= (WORD)sValue.GetLength();			nLoop1	++;			}		// ########################################		// Reallocate heap memory. ################		nAddSize = nSizeOffsets + sValue.GetLength() + 1;		if( m_nHeapUsedSize + nAddSize > m_nHeapAllocSize )			{			m_pBuffer			= (BYTE*)HeapReAlloc(m_hHeap, 0L, m_pBuffer, m_nHeapAllocSize + nHeapBlock);			m_nHeapAllocSize	+= nHeapBlock;			ASSERT( m_pBuffer );			}		// #######################################		// Add offsets array at the head of string.		memcpy(&m_pBuffer[m_nHeapUsedSize], pStrOffsets, nSizeOffsets);		m_nHeapUsedSize += nSizeOffsets;		// #######################################		// Add full string to array. #############		char* pFullString = (char*)&m_pBuffer[m_nHeapUsedSize];		strcpy(pFullString, sValue.GetBuffer());		m_arrFullStrings.Add(lData, (long)m_nHeapUsedSize);		m_nHeapUsedSize += sValue.GetLength() + 1;		// #######################################		pRst->MoveNext(); nLoop ++; nSize += sValue.GetLength() + 1; 		}	// ###########################################		// Add full strings(sorted order) to array.##	m_pStringBuffer = new BYTE[nSize];	m_nOffset		= 0;	m_nBuffSize		= nSize;	while( nItem < nLoop )		{		lData	= (long)m_arrFullStrings[nItem];		sValue	= ((LPCTSTR)&m_pBuffer[m_arrFullStrings.GetData(nItem)]);		// Add string(cutted to small parts) into buffer and array. ##		AddStringToBufferArray(&sValue, lData);		// ###########################################################		nItem ++;		}	// ###########################################	pRst->Close();	m_arrSearchResult.Copy(&m_arrFullStrings);	delete pStrOffsets;	return nLoop;	}

BOOLGetAccountSid(    LPTSTR SystemName,    LPTSTR AccountName,    PSID *Sid    ){    LPTSTR ReferencedDomain=NULL;    LPTSTR TempReferencedDomain = NULL;    LPTSTR TempSid = NULL;    DWORD cbSid=128;    // initial allocation attempt    DWORD cchReferencedDomain=16; // initial allocation size    SID_NAME_USE peUse;    BOOL bSuccess=FALSE; // assume this function will fail    __try {    //    // initial memory allocations    //    *Sid = (PSID)HeapAlloc(GetProcessHeap(), 0, cbSid);    if(*Sid == NULL) __leave;    ReferencedDomain = (LPTSTR)HeapAlloc(                    GetProcessHeap(),                    0,                    cchReferencedDomain * sizeof(TCHAR)                    );    if(ReferencedDomain == NULL) __leave;    //    // Obtain the SID of the specified account on the specified system.    //    while(!LookupAccountName(                    SystemName,         // machine to lookup account on                    AccountName,        // account to lookup                    *Sid,               // SID of interest                    &cbSid,             // size of SID                    ReferencedDomain,   // domain account was found on                    &cchReferencedDomain,                    &peUse                    )) {        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {            //            // reallocate memory            //            TempSid  = (PSID)HeapReAlloc(                        GetProcessHeap(),                        0,                        *Sid,                        cbSid                        );            if(TempSid  == NULL) __leave;            *Sid = TempSid;            TempReferencedDomain = (LPTSTR)HeapReAlloc(                        GetProcessHeap(),                        0,                        ReferencedDomain,                        cchReferencedDomain * sizeof(TCHAR)                        );            if(TempReferencedDomain == NULL) __leave;            ReferencedDomain = TempReferencedDomain;                      }        else __leave;    }    //    // Indicate success.    //    bSuccess=TRUE;    } // try    __finally {    //    // Cleanup and indicate failure, if appropriate.    //    HeapFree(GetProcessHeap(), 0, ReferencedDomain);    if(!bSuccess) {        if(*Sid != NULL) {            HeapFree(GetProcessHeap(), 0, *Sid);            *Sid = NULL;        }    }    } // finally    return bSuccess;}

/* find all drivers that can be loaded */static void findAudioDrivers(void){    int numFound = 0;    AUDIO_DRIVER *pAudioDrv = NULL;    HCURSOR old_cursor;    /* delete an existing list */    HeapFree(GetProcessHeap(), 0, loadedAudioDrv);    loadedAudioDrv = 0;    /* change to the wait cursor because this can take a while if there is a     * misbehaving driver that takes a long time to open     */    old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));    for (pAudioDrv = sAudioDrivers; pAudioDrv->nameID; pAudioDrv++)    {        if (strlen(pAudioDrv->szDriver))        {            HDRVR hdrv;            char driver[MAX_PATH];            sprintf(driver, "wine%s.drv", pAudioDrv->szDriver);            hdrv = pAudioDrv->hDriver;            if (!pAudioDrv->hDriver && (hdrv = OpenDriverA(driver, 0, 0))) {                HMODULE lib = GetDriverModuleHandle(hdrv);                MessagePtr wodMessagePtr = (MessagePtr)GetProcAddress(lib, "wodMessage");                MessagePtr widMessagePtr = (MessagePtr)GetProcAddress(lib, "widMessage");                MessagePtr modMessagePtr = (MessagePtr)GetProcAddress(lib, "modMessage");                MessagePtr midMessagePtr = (MessagePtr)GetProcAddress(lib, "midMessage");                MessagePtr auxMessagePtr = (MessagePtr)GetProcAddress(lib, "auxMessage");                MessagePtr mxdMessagePtr = (MessagePtr)GetProcAddress(lib, "mxdMessage");                pAudioDrv->hDriver = hdrv;                if (wodMessagePtr)                    wodMessagePtr(0, DRVM_INIT, 0, 0, 0);                if (widMessagePtr)                    widMessagePtr(0, DRVM_INIT, 0, 0, 0);                if (modMessagePtr)                    modMessagePtr(0, DRVM_INIT, 0, 0, 0);                if (midMessagePtr)                    midMessagePtr(0, DRVM_INIT, 0, 0, 0);                if (auxMessagePtr)                    auxMessagePtr(0, DRVM_INIT, 0, 0, 0);                if (mxdMessagePtr)                    mxdMessagePtr(0, DRVM_INIT, 0, 0, 0);            }            if (hdrv)            {                if (loadedAudioDrv)                    loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));                else                    loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));                CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));                numFound++;            }        }    }    /* restore the original cursor */    SetCursor(old_cursor);    /* terminate list with empty driver */    if (numFound) {        loadedAudioDrv = HeapReAlloc(GetProcessHeap(), 0, loadedAudioDrv, (numFound + 1) * sizeof(AUDIO_DRIVER));        CopyMemory(&loadedAudioDrv[numFound], pAudioDrv, sizeof(AUDIO_DRIVER));    } else {        loadedAudioDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(AUDIO_DRIVER));        CopyMemory(&loadedAudioDrv[0], pAudioDrv, sizeof(AUDIO_DRIVER));    }}

void __declspec(dllexport) CreateControl(HWND hwndParent, int string_size, char *variables, stack_t **stacktop, extra_parameters *extra){  char *className;  char *text;  HWND hwItem;  int x, y, width, height;  DWORD style, exStyle;  size_t id;  // get info from stack  className = (char *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_stringsize * 2);  text = &className[g_stringsize];  if (!className)  {    pushstring("error");    return;  }  if (popstringn(className, 0))  {    pushstring("error");    HeapFree(GetProcessHeap(), 0, className);    return;  }  style = (DWORD) popint_or();  exStyle = (DWORD) popint_or();  PopPlacement(&x, &y, &width, &height);  if (popstringn(text, 0))  {    pushstring("error");    HeapFree(GetProcessHeap(), 0, className);    return;  }  // create item descriptor  id = g_dialog.controlCount;  g_dialog.controlCount++;  g_dialog.controls = (struct nsControl*) HeapReAlloc(    GetProcessHeap(),    HEAP_ZERO_MEMORY,    g_dialog.controls,    g_dialog.controlCount * sizeof(struct nsControl));  if (!lstrcmpi(className, "BUTTON"))    g_dialog.controls[id].type = NSCTL_BUTTON;  else if (!lstrcmpi(className, "EDIT"))    g_dialog.controls[id].type = NSCTL_EDIT;  else if (!lstrcmpi(className, "COMBOBOX"))    g_dialog.controls[id].type = NSCTL_COMBOBOX;  else if (!lstrcmpi(className, "LISTBOX"))    g_dialog.controls[id].type = NSCTL_LISTBOX;  else if (!lstrcmpi(className, "RichEdit"))    g_dialog.controls[id].type = NSCTL_RICHEDIT;  else if (!lstrcmpi(className, "RICHEDIT_CLASS"))    g_dialog.controls[id].type = NSCTL_RICHEDIT2;  else if (!lstrcmpi(className, "STATIC"))    g_dialog.controls[id].type = NSCTL_STATIC;  else if (!lstrcmpi(className, "LINK"))    g_dialog.controls[id].type = NSCTL_LINK;  else    g_dialog.controls[id].type = NSCTL_UNKNOWN;  // apply rtl to style  ConvertStyleToRTL(g_dialog.controls[id].type, &style, &exStyle);  // create item's window  hwItem = CreateWindowEx(    exStyle,    lstrcmpi(className, "LINK") ? className : "BUTTON",    text,    style,    x, y, width, height,    g_dialog.hwDialog,    (HMENU) (1200 + id),    g_hInstance,    NULL);  g_dialog.controls[id].window = hwItem;  // remember id  SetProp(hwItem, NSCONTROL_ID_PROP, (HANDLE) (id + 1));  // set font  SendMessage(hwItem, WM_SETFONT, SendMessage(g_dialog.hwParent, WM_GETFONT, 0, 0), TRUE);  // set the WndProc for the link control  if(g_dialog.controls[id].type == NSCTL_LINK)    g_dialog.controls[id].oldWndProc = (WNDPROC) SetWindowLong(hwItem, GWL_WNDPROC, (long) LinkWndProc);//.........这里部分代码省略.........

int __stdcall AddClientDV ( LPDVINFO lpDVInfo ){    BOOL bRet = TRUE ;    __try    {        __try        {            // Check all the parameters.            ASSERT ( NULL != lpDVInfo ) ;            ASSERT ( FALSE ==                          IsBadCodePtr ( (FARPROC)lpDVInfo->pfnDump) ) ;            ASSERT ( FALSE ==                       IsBadCodePtr ( (FARPROC)lpDVInfo->pfnValidate ));            ASSERT ( 0 == lpDVInfo->dwValue ) ;            if ( ( NULL == lpDVInfo )                                ||                 ( TRUE ==                      IsBadCodePtr((FARPROC)lpDVInfo->pfnDump     ) )||                 ( TRUE ==                      IsBadCodePtr((FARPROC)lpDVInfo->pfnValidate ) )||                 ( 0 != lpDVInfo->dwValue                           )  )            {                TRACE ( "Bad parameters to AddClientDV/n" );                return ( FALSE ) ;            }            // Has everything been initialized?            if ( FALSE == g_bLibInit )            {                InitializeLibrary ( ) ;            }            // Block access to the library.            EnterCriticalSection ( &g_stCritSec ) ;            // No matter what, bump up g_dwDVCount.            g_dwDVCount++ ;            // Check that this is not one bump too many.            ASSERT ( (WORD)g_dwDVCount < (WORD)0xFFFF ) ;            if ( (WORD)g_dwDVCount == (WORD)0xFFFF )            {                bRet = FALSE ;                __leave ;            }            // Generate the client block ID.            lpDVInfo->dwValue = CLIENT_BLOCK_VALUE ( g_dwDVCount ) ;            // Is this the first time through?            if ( 1 == g_dwDVCount )            {                ASSERT ( NULL == g_pstDVInfo ) ;                // Allocate the array for the first time.                g_pstDVInfo =                       (LPDVINFO)HeapAlloc ( g_hHeap                  ,                                             HEAP_GENERATE_EXCEPTIONS |                                              HEAP_ZERO_MEMORY        ,                                             sizeof ( DVINFO )        );                g_pstDVInfo[ 0 ] = *lpDVInfo ;            }            else            {                // This is not the first time so reallocate the array                // and tack this new puppy on the end.                g_pstDVInfo =                    (LPDVINFO)HeapReAlloc ( g_hHeap                     ,                                            HEAP_GENERATE_EXCEPTIONS |                                                HEAP_ZERO_MEMORY        ,                                            g_pstDVInfo                 ,                                            g_dwDVCount *                                                      sizeof ( DVINFO));                g_pstDVInfo[ g_dwDVCount - 1 ] = *lpDVInfo ;            }        }        __except ( EXCEPTION_EXECUTE_HANDLER )        {            ASSERT ( !"Had a crash in AddClientDV!" ) ;            bRet = FALSE ;        }    }    __finally    {        LeaveCriticalSection ( &g_stCritSec ) ;    }    return ( bRet ) ;}

/****************************************************************** *		font_enum_size * * */static int CALLBACK font_enum_size(const LOGFONT* lf, const TEXTMETRIC* tm,                                   DWORD FontType, LPARAM lParam){    struct dialog_info*	di = (struct dialog_info*)lParam;    WCHAR	        buf[32];    static const WCHAR  fmt[] = {'%','l','d',0};    WCUSER_DumpTextMetric(tm, FontType);    if (di->nFont == 0 && !(FontType & RASTER_FONTTYPE))    {        static const int sizes[] = {8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72};        int i;        di->nFont = sizeof(sizes) / sizeof(sizes[0]);        di->font = HeapAlloc(GetProcessHeap(), 0, di->nFont * sizeof(di->font[0]));        for (i = 0; i < di->nFont; i++)        {            /* drop sizes where window size wouldn't fit on screen */            if (sizes[i] * di->data->curcfg.win_height > GetSystemMetrics(SM_CYSCREEN))            {                di->nFont = i;                break;            }            di->font[i].height = sizes[i];            di->font[i].weight = 400;            lstrcpy(di->font[i].faceName, lf->lfFaceName);            wsprintf(buf, fmt, sizes[i]);            SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, i, (LPARAM)buf);        }        /* don't need to enumerate other */        return 0;    }    if (WCUSER_ValidateFontMetric(di->data, tm, FontType))    {        int	idx;        /* we want the string to be sorted with a numeric order, not a lexicographic...         * do the job by hand... get where to insert the new string         */        for (idx = 0; idx < di->nFont && tm->tmHeight > di->font[idx].height; idx++);        while (idx < di->nFont &&                tm->tmHeight == di->font[idx].height &&                tm->tmWeight > di->font[idx].weight)            idx++;        if (idx == di->nFont ||                tm->tmHeight != di->font[idx].height ||                tm->tmWeight < di->font[idx].weight)        {            /* here we need to add the new entry */            wsprintf(buf, fmt, tm->tmHeight);            SendDlgItemMessage(di->hDlg, IDC_FNT_LIST_SIZE, LB_INSERTSTRING, idx, (LPARAM)buf);            /* now grow our arrays and insert the values at the same index than in the list box */            if (di->nFont)            {                di->font = HeapReAlloc(GetProcessHeap(), 0, di->font, sizeof(*di->font) * (di->nFont + 1));                if (idx != di->nFont)                    memmove(&di->font[idx + 1], &di->font[idx], (di->nFont - idx) * sizeof(*di->font));            }            else                di->font = HeapAlloc(GetProcessHeap(), 0, sizeof(*di->font));            di->font[idx].height = tm->tmHeight;            di->font[idx].weight = tm->tmWeight;            lstrcpy(di->font[idx].faceName, lf->lfFaceName);            di->nFont++;        }    }    return 1;}

static inline LRESULTHexEdit_Char (HEXEDIT_INFO *infoPtr, TCHAR ch){    INT nCaretBytePos = infoPtr->nCaretPos/2;    assert(nCaretBytePos >= 0);    /* backspace is special */    if (ch == '/b')    {        if (infoPtr->nCaretPos == 0)            return 0;        /* if at end of byte then delete the whole byte */        if (infoPtr->bFocusHex && (infoPtr->nCaretPos % 2 == 0))        {            memmove(infoPtr->pData + nCaretBytePos - 1,                    infoPtr->pData + nCaretBytePos,                    infoPtr->cbData - nCaretBytePos);            infoPtr->cbData--;            infoPtr->nCaretPos -= 2; /* backtrack two nibble */        }        else /* blank upper nibble */        {            infoPtr->pData[nCaretBytePos] &= 0x0f;            infoPtr->nCaretPos--; /* backtrack one nibble */        }    }    else    {        if (infoPtr->bFocusHex && hexchar_to_byte(ch) == (BYTE)-1)        {            MessageBeep(MB_ICONWARNING);            return 0;        }        if ((infoPtr->bInsert && (infoPtr->nCaretPos % 2 == 0)) || (nCaretBytePos >= infoPtr->cbData))        {            /* make room for another byte */            infoPtr->cbData++;            infoPtr->pData = HeapReAlloc(GetProcessHeap(), 0, infoPtr->pData, infoPtr->cbData + 1);            if (!infoPtr->pData) return 0;            /* move everything after caret up one byte */            memmove(infoPtr->pData + nCaretBytePos + 1,                    infoPtr->pData + nCaretBytePos,                    infoPtr->cbData - nCaretBytePos);            /* zero new byte */            infoPtr->pData[nCaretBytePos] = 0x0;        }        /* overwrite a byte */        assert(nCaretBytePos < infoPtr->cbData);        if (infoPtr->bFocusHex)        {            BYTE orig_byte = infoPtr->pData[nCaretBytePos];            BYTE digit = hexchar_to_byte(ch);            if (infoPtr->nCaretPos % 2) /* set low nibble */                infoPtr->pData[nCaretBytePos] = (orig_byte & 0xf0) | digit;            else /* set high nibble */                infoPtr->pData[nCaretBytePos] = (orig_byte & 0x0f) | digit << 4;            infoPtr->nCaretPos++; /* advance one nibble */        }        else        {            infoPtr->pData[nCaretBytePos] = (BYTE)ch;            infoPtr->nCaretPos += 2; /* advance two nibbles */        }    }    HexEdit_UpdateScrollbars(infoPtr);    InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);    HexEdit_UpdateCaret(infoPtr);    HexEdit_EnsureVisible(infoPtr, infoPtr->nCaretPos);    return 0;}

BOOL nulldrv_PolyDraw( PHYSDEV dev, const POINT *points, const BYTE *types, DWORD count ){    DC *dc = get_nulldrv_dc( dev );    POINT *line_pts = NULL, *bzr_pts = NULL, bzr[4];    DWORD i;    INT num_pts, num_bzr_pts, space, size;    /* check for valid point types */    for (i = 0; i < count; i++)    {        switch (types[i])        {        case PT_MOVETO:        case PT_LINETO | PT_CLOSEFIGURE:        case PT_LINETO:            break;        case PT_BEZIERTO:            if (i + 2 >= count) return FALSE;            if (types[i + 1] != PT_BEZIERTO) return FALSE;            if ((types[i + 2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO) return FALSE;            i += 2;            break;        default:            return FALSE;        }    }    space = count + 300;    line_pts = HeapAlloc( GetProcessHeap(), 0, space * sizeof(POINT) );    num_pts = 1;    line_pts[0] = dc->cur_pos;    for (i = 0; i < count; i++)    {        switch (types[i])        {        case PT_MOVETO:            if (num_pts >= 2) Polyline( dev->hdc, line_pts, num_pts );            num_pts = 0;            line_pts[num_pts++] = points[i];            break;        case PT_LINETO:        case (PT_LINETO | PT_CLOSEFIGURE):            line_pts[num_pts++] = points[i];            break;        case PT_BEZIERTO:            bzr[0].x = line_pts[num_pts - 1].x;            bzr[0].y = line_pts[num_pts - 1].y;            memcpy( &bzr[1], &points[i], 3 * sizeof(POINT) );            if ((bzr_pts = GDI_Bezier( bzr, 4, &num_bzr_pts )))            {                size = num_pts + (count - i) + num_bzr_pts;                if (space < size)                {                    space = size * 2;                    line_pts = HeapReAlloc( GetProcessHeap(), 0, line_pts, space * sizeof(POINT) );                }                memcpy( &line_pts[num_pts], &bzr_pts[1], (num_bzr_pts - 1) * sizeof(POINT) );                num_pts += num_bzr_pts - 1;                HeapFree( GetProcessHeap(), 0, bzr_pts );            }            i += 2;            break;        }        if (types[i] & PT_CLOSEFIGURE) line_pts[num_pts++] = line_pts[0];    }    if (num_pts >= 2) Polyline( dev->hdc, line_pts, num_pts );    HeapFree( GetProcessHeap(), 0, line_pts );    return TRUE;}

void *globalrealloc(void *oldp,size_t newsize){#if 0    void *p;    // Initialize heap    if (!hHeap)    {   hHeap = HeapCreate(0,0x10000,0);        if (!hHeap)            os_error();    }    newsize = (newsize + 3) & ~3L;      // round up to dwords    if (newsize == 0)    {        if (oldp && HeapFree(hHeap,0,oldp) == FALSE)            os_error();        p = NULL;    }    else if (!oldp)    {        p = newsize ? HeapAlloc(hHeap,0,newsize) : NULL;    }    else        p = HeapReAlloc(hHeap,0,oldp,newsize);#elif 1    MEMORY_BASIC_INFORMATION query;    void *p;    BOOL bSuccess;    if (!oldp)        p = VirtualAlloc (NULL, newsize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);    else    {        VirtualQuery (oldp, &query, sizeof(query));        if (!newsize)        {            p = NULL;            goto L1;        }        else        {   newsize = (newsize + 0xFFFF) & ~0xFFFFL;            if (query.RegionSize >= newsize)                p = oldp;            else            {   p = VirtualAlloc(NULL,newsize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);                if (p)                    memcpy(p,oldp,query.RegionSize);            L1:                bSuccess = VirtualFree(oldp,query.RegionSize,MEM_DECOMMIT);                if (bSuccess)                    bSuccess = VirtualFree(oldp,0,MEM_RELEASE);                if (!bSuccess)                    os_error();            }        }    }#else    void *p;    if (!oldp)        p = (void *)GlobalAlloc (0, newsize);    else if (!newsize)    {   GlobalFree(oldp);        p = NULL;    }    else        p = (void *)GlobalReAlloc(oldp,newsize,0);#endif    dbg_printf("globalrealloc(oldp = %p, size = x%x) = %p/n",oldp,newsize,p);    return p;}

static int UpdateFileData(    HWND hDlg,    LPCSTR szDataToFill,    size_t OffsetToFill,    UINT FillPattern){    TFileTestData * pData = GetDialogData(hDlg);    LONGLONG ByteOffset;    LPBYTE WritePattern = (LPBYTE)"BAADF00D";    ULONG NewLength;    ULONG i;    size_t cchDataToFill = 0;    HWND hWndChild = GetDlgItem(hDlg, IDC_FILE_DATA);    // Get the byte offset    DlgText2Hex64(hDlg, IDC_BYTE_OFFSET, &ByteOffset);    DlgText2Hex32(hDlg, IDC_LENGTH, &NewLength);    // Clear the file data from the data editor    DataEditor_SetData(hWndChild, 0, NULL, 0);    // Determine the new length of the data    if(szDataToFill != NULL)    {        cchDataToFill = strlen(szDataToFill);        NewLength = (ULONG)(OffsetToFill + cchDataToFill);    }    // If we need to increase the buffer size, do it    if(NewLength > pData->cbFileDataMax)    {        pData->pbFileData = (LPBYTE)HeapReAlloc(g_hHeap, HEAP_ZERO_MEMORY, pData->pbFileData, NewLength);        if(pData->pbFileData == NULL)            return ERROR_NOT_ENOUGH_MEMORY;        pData->cbFileDataMax = NewLength;    }    // If we shall fill the data with custom data, do it    if(szDataToFill != NULL)    {        // Fill the gap after end of current data with zeros        if(OffsetToFill > pData->cbFileData)            memset(pData->pbFileData + pData->cbFileData, 0, OffsetToFill - pData->cbFileData);        memcpy(pData->pbFileData + OffsetToFill, szDataToFill, cchDataToFill);    }    // If the caller required us to fill the data with pattern, do it    else    {        // If the new pattern is zero, it means to fill the same pattern like before        if(FillPattern == 0)            FillPattern = pData->FillPattern;        // If the pattern is the same like before, just fill the remaining part        if(OffsetToFill < NewLength)        {            switch(FillPattern)            {            case IDC_FILL_DATA_ZEROS:                memset(pData->pbFileData + OffsetToFill, 0, NewLength - OffsetToFill);                break;            case IDC_FILL_DATA_PATTERN:                for(i = (ULONG)OffsetToFill; i < NewLength; i++)                    pData->pbFileData[i] = WritePattern[i % 8];                break;            case IDC_FILL_DATA_RANDOM:                srand(GetTickCount());                for(i = (ULONG)OffsetToFill; i < NewLength; i++)                    pData->pbFileData[i] = (BYTE)(rand() % 0x100);                break;            }        }        // Remember the current pattern        pData->FillPattern = FillPattern;    }    // Remember the new data length    if(NewLength != pData->cbFileData)    {        Hex2DlgText32(hDlg, IDC_LENGTH, NewLength);        pData->cbFileData = NewLength;    }    // Apply the new file data    DataEditor_SetData(hWndChild, ByteOffset, pData->pbFileData, pData->cbFileData);    return ERROR_SUCCESS;}