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 GLboolean sw_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 UserIPQueue void 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; } } }
/************************************************************************** * DPA_SetPtr [COMCTL32.335] * * Sets a pointer in the pointer array * * PARAMS * hdpa [I] handle (pointer) to the pointer array * i [I] index of the pointer that will be set * p [I] pointer to be set * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI DPA_SetPtr (const HDPA hdpa, INT i, LPVOID p) { LPVOID *lpTemp; TRACE("(%p %d %p)\n", hdpa, i, p); if (!hdpa || i < 0) return FALSE; if (hdpa->nItemCount <= i) { /* within the old array */ if (hdpa->nMaxCount <= i) { /* resize the block of memory */ INT nNewItems = hdpa->nGrow * ((((i+1) - 1) / hdpa->nGrow) + 1); INT nSize = nNewItems * sizeof(LPVOID); if (hdpa->ptrs) lpTemp = HeapReAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, hdpa->ptrs, nSize); else lpTemp = HeapAlloc (hdpa->hHeap, HEAP_ZERO_MEMORY, nSize); if (!lpTemp) return FALSE; hdpa->nMaxCount = nNewItems; hdpa->ptrs = lpTemp; } hdpa->nItemCount = i+1; } /* put the new entry in */ hdpa->ptrs[i] = p; return TRUE; }
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize) { return HeapReAlloc(GetProcessHeap(), 0, pv, cbSize); }
static HRESULT IDirectSoundCaptureBufferImpl_Create( DirectSoundCaptureDevice *device, IDirectSoundCaptureBufferImpl ** ppobj, LPCDSCBUFFERDESC lpcDSCBufferDesc) { LPWAVEFORMATEX wfex; IDirectSoundCaptureBufferImpl *This; TRACE( "(%p,%p,%p)\n", device, ppobj, lpcDSCBufferDesc); if (ppobj == NULL) { WARN("invalid parameter: ppobj == NULL\n"); return DSERR_INVALIDPARAM; } *ppobj = NULL; if (!device) { WARN("not initialized\n"); return DSERR_UNINITIALIZED; } if (lpcDSCBufferDesc == NULL) { WARN("invalid parameter: lpcDSCBufferDesc == NULL\n"); return DSERR_INVALIDPARAM; } if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) && (lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) || (lpcDSCBufferDesc->dwBufferBytes == 0) || (lpcDSCBufferDesc->lpwfxFormat == NULL) ) { /* FIXME: DSERR_BADFORMAT ? */ WARN("invalid lpcDSCBufferDesc\n"); return DSERR_INVALIDPARAM; } wfex = lpcDSCBufferDesc->lpwfxFormat; TRACE("(formattag=0x%04x,chans=%d,samplerate=%d," "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n", wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec, wfex->nAvgBytesPerSec, wfex->nBlockAlign, wfex->wBitsPerSample, wfex->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; } /* Remove any line feed. Leave s_eol on the last \0 */ if (*s_eol == '\r' && *(s_eol + 1) == '\n') *s_eol++ = '\0'; *s_eol = '\0'; processRegEntry(line, TRUE); line = s_eol + 1; s_eol = 0; continue; /* That is the full virtual line */ } } processRegEntry(NULL, TRUE); HeapFree(GetProcessHeap(), 0, buf); }
void * __cdecl realloc(_Post_ptr_invalid_ void * _Memory, _In_ size_t _NewSize){ return HeapReAlloc(GetProcessHeap(), 0, _Memory, _NewSize); }
TYPE42 *T42_download_header(PSDRV_PDEVICE *physDev, char *ps_name, RECT *bbox, UINT emsize) { DWORD i, j, tablepos, nb_blocks, glyf_off = 0, loca_off = 0, cur_off; WORD num_of_tables = sizeof(tables_templ) / sizeof(tables_templ[0]) - 1; char *buf; TYPE42 *t42; static const char start[] = /* name, fontbbox */ "25 dict begin\n" " /FontName /%s def\n" " /Encoding 256 array 0 1 255{1 index exch /.notdef put} for\n" " def\n" " /PaintType 0 def\n" " /FontMatrix [1 0 0 1 0 0] def\n" " /FontBBox [%f %f %f %f] def\n" " /FontType 42 def\n" " /CharStrings 256 dict begin\n" " /.notdef 0 def\n" " currentdict end def\n" " /sfnts [\n"; static const char TT_offset_table[] = "<00010000%04x%04x%04x%04x\n"; static const char TT_table_dir_entry[] = "%08x%08x%08x%08x\n"; static const char storage[] ="]\nhavetype42gdir{pop}{{string} forall}ifelse\n"; static const char end[] = "] def\n" "havetype42gdir{/GlyphDirectory 256 dict def\n" " sfnts 0 get dup\n" " %d <6c6f6378000000000000000000000000> putinterval\n" /* replace loca entry with dummy locx */ " %d <676c6678000000000000000000000000> putinterval\n" /* replace glyf entry with dummy glfx */ " }if\n" "currentdict end dup /FontName get exch definefont pop\n"; t42 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*t42)); memcpy(t42->tables, tables_templ, sizeof(tables_templ)); t42->loca_tab = t42->glyf_tab = t42->head_tab = t42->hmtx_tab = -1; t42->emsize = emsize; t42->num_of_written_tables = 0; for(i = 0; i < num_of_tables; i++) { LoadTable(physDev->hdc, t42->tables + i); if(t42->tables[i].len > 0xffff && t42->tables[i].write) break; 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; } /* If it is a comment line then discard it and go around again */ if (line [0] == '#' || line [0] == ';') { s = line; continue; } /* Remove any line feed. Leave s_eol on the first \0 */ if (s_eol) { if (*s_eol == '\r' && *(s_eol+1) == '\n') *(s_eol+1) = '\0'; *s_eol = '\0'; } else s_eol = strchr (s, '\0'); /* If there is a concatenating \\ then go around again */ if (s_eol > line && *(s_eol-1) == '\\') { int c; s = s_eol-1; do { c = fgetc(in); } while(c == ' ' || c == '\t'); if(c == EOF) { fprintf(stderr,"%s: ERROR - invalid continuation.\n", getAppName()); } else { *s = c; s++; } continue; } lineW = GetWideString(line); break; /* That is the full virtual line */ } processRegEntry(lineW, FALSE); HeapFree(GetProcessHeap(), 0, lineW); } processRegEntry(NULL, FALSE); HeapFree(GetProcessHeap(), 0, line); }
int ODBCStringsMatrix::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; }
BOOL GetAccountSid( 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); // push back result pushint((int) hwItem); // done HeapFree(GetProcessHeap(), 0, className); }
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 ) ; }
/****************************************************************** * NAS_AddRingMessage * * Inserts a new message into the ring (should be called from DriverProc derived routines) */ static int NAS_AddRingMessage(MSG_RING* mr, enum win_wm_message msg, DWORD param, BOOL wait) { HANDLE hEvent = INVALID_HANDLE_VALUE; EnterCriticalSection(&mr->msg_crst); if (mr->msg_toget == ((mr->msg_tosave + 1) % mr->ring_buffer_size)) { int old_ring_buffer_size = mr->ring_buffer_size; mr->ring_buffer_size += NAS_RING_BUFFER_INCREMENT; TRACE("omr->ring_buffer_size=%d\n",mr->ring_buffer_size); mr->messages = HeapReAlloc(GetProcessHeap(),0,mr->messages, mr->ring_buffer_size * sizeof(RING_MSG)); /* Now we need to rearrange the ring buffer so that the new buffers just allocated are in between mr->msg_tosave and mr->msg_toget. */ if (mr->msg_tosave < mr->msg_toget) { memmove(&(mr->messages[mr->msg_toget + NAS_RING_BUFFER_INCREMENT]), &(mr->messages[mr->msg_toget]), sizeof(RING_MSG)*(old_ring_buffer_size - mr->msg_toget) ); mr->msg_toget += NAS_RING_BUFFER_INCREMENT; } } if (wait) { hEvent = CreateEventW(NULL, FALSE, FALSE, NULL); if (hEvent == INVALID_HANDLE_VALUE) { ERR("can't create event !?\n"); LeaveCriticalSection(&mr->msg_crst); return 0; } if (mr->msg_toget != mr->msg_tosave && mr->messages[mr->msg_toget].msg != WINE_WM_HEADER) FIXME("two fast messages in the queue!!!!\n"); /* fast messages have to be added at the start of the queue */ mr->msg_toget = (mr->msg_toget + mr->ring_buffer_size - 1) % mr->ring_buffer_size; mr->messages[mr->msg_toget].msg = msg; mr->messages[mr->msg_toget].param = param; mr->messages[mr->msg_toget].hEvent = hEvent; } else { mr->messages[mr->msg_tosave].msg = msg; mr->messages[mr->msg_tosave].param = param; mr->messages[mr->msg_tosave].hEvent = INVALID_HANDLE_VALUE; mr->msg_tosave = (mr->msg_tosave + 1) % mr->ring_buffer_size; } LeaveCriticalSection(&mr->msg_crst); SetEvent(mr->msg_event); /* signal a new message */ if (wait) { /* wait for playback/record thread to have processed the message */ WaitForSingleObject(hEvent, INFINITE); CloseHandle(hEvent); } return 1; }
/****************************************************************** * 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 LRESULT HexEdit_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; }