?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Changes in crossover-wine-src-6.1.0 except for configure
[wine/hacks.git] / dlls / gdi32 / mfdrv / init.c
blobe939ce1392502fbc3308002077119014a70f4932
1 /*
2 * Metafile driver initialisation functions
3 *
4 * Copyright 1996 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22 #include <string.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wine/winbase16.h"
27 #include "wownt32.h"
28 #include "gdi_private.h"
29 #include "mfdrv/metafiledrv.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(metafile);
33
34 static const DC_FUNCTIONS MFDRV_Funcs =
35 {
36 NULL, /* pAbortDoc */
37 MFDRV_AbortPath, /* pAbortPath */
38 NULL, /* pAlphaBlend */
39 NULL, /* pAngleArc */
40 MFDRV_Arc, /* pArc */
41 NULL, /* pArcTo */
42 MFDRV_BeginPath, /* pBeginPath */
43 MFDRV_BitBlt, /* pBitBlt */
44 NULL, /* pChoosePixelFormat */
45 MFDRV_Chord, /* pChord */
46 MFDRV_CloseFigure, /* pCloseFigure */
47 NULL, /* pCreateBitmap */
48 NULL, /* pCreateDC */
49 NULL, /* pCreateDIBSection */
50 NULL, /* pDeleteBitmap */
51 NULL, /* pDeleteDC */
52 MFDRV_DeleteObject, /* pDeleteObject */
53 NULL, /* pDescribePixelFormat */
54 NULL, /* pDeviceCapabilities */
55 MFDRV_Ellipse, /* pEllipse */
56 NULL, /* pEndDoc */
57 NULL, /* pEndPage */
58 MFDRV_EndPath, /* pEndPath */
59 NULL, /* pEnumDeviceFonts */
60 MFDRV_ExcludeClipRect, /* pExcludeClipRect */
61 NULL, /* pExtDeviceMode */
62 MFDRV_ExtEscape, /* pExtEscape */
63 MFDRV_ExtFloodFill, /* pExtFloodFill */
64 MFDRV_ExtSelectClipRgn, /* pExtSelectClipRgn */
65 MFDRV_ExtTextOut, /* pExtTextOut */
66 MFDRV_FillPath, /* pFillPath */
67 MFDRV_FillRgn, /* pFillRgn */
68 MFDRV_FlattenPath, /* pFlattenPath */
69 MFDRV_FrameRgn, /* pFrameRgn */
70 NULL, /* pGdiComment */
71 NULL, /* pGetBitmapBits */
72 NULL, /* pGetCharWidth */
73 NULL, /* pGetDCOrgEx */
74 NULL, /* pGetDIBColorTable */
75 NULL, /* pGetDIBits */
76 MFDRV_GetDeviceCaps, /* pGetDeviceCaps */
77 NULL, /* pGetDeviceGammaRamp */
78 NULL, /* pGetNearestColor */
79 NULL, /* pGetPixel */
80 NULL, /* pGetPixelFormat */
81 NULL, /* pGetSystemPaletteEntries */
82 NULL, /* pGetTextExtentExPoint */
83 NULL, /* pGetTextMetrics */
84 MFDRV_IntersectClipRect, /* pIntersectClipRect */
85 MFDRV_InvertRgn, /* pInvertRgn */
86 MFDRV_LineTo, /* pLineTo */
87 NULL, /* pModifyWorldTransform */
88 MFDRV_MoveTo, /* pMoveTo */
89 MFDRV_OffsetClipRgn, /* pOffsetClipRgn */
90 MFDRV_OffsetViewportOrg, /* pOffsetViewportOrg */
91 MFDRV_OffsetWindowOrg, /* pOffsetWindowOrg */
92 MFDRV_PaintRgn, /* pPaintRgn */
93 MFDRV_PatBlt, /* pPatBlt */
94 MFDRV_Pie, /* pPie */
95 MFDRV_PolyBezier, /* pPolyBezier */
96 MFDRV_PolyBezierTo, /* pPolyBezierTo */
97 NULL, /* pPolyDraw */
98 MFDRV_PolyPolygon, /* pPolyPolygon */
99 NULL, /* pPolyPolyline */
100 MFDRV_Polygon, /* pPolygon */
101 MFDRV_Polyline, /* pPolyline */
102 NULL, /* pPolylineTo */
103 NULL, /* pRealizeDefaultPalette */
104 MFDRV_RealizePalette, /* pRealizePalette */
105 MFDRV_Rectangle, /* pRectangle */
106 NULL, /* pResetDC */
107 MFDRV_RestoreDC, /* pRestoreDC */
108 MFDRV_RoundRect, /* pRoundRect */
109 MFDRV_SaveDC, /* pSaveDC */
110 MFDRV_ScaleViewportExt, /* pScaleViewportExt */
111 MFDRV_ScaleWindowExt, /* pScaleWindowExt */
112 MFDRV_SelectBitmap, /* pSelectBitmap */
113 MFDRV_SelectBrush, /* pSelectBrush */
114 MFDRV_SelectClipPath, /* pSelectClipPath */
115 MFDRV_SelectFont, /* pSelectFont */
116 MFDRV_SelectPalette, /* pSelectPalette */
117 MFDRV_SelectPen, /* pSelectPen */
118 NULL, /* pSetArcDirection */
119 NULL, /* pSetBitmapBits */
120 MFDRV_SetBkColor, /* pSetBkColor */
121 MFDRV_SetBkMode, /* pSetBkMode */
122 NULL, /* pSetDCBrushColor*/
123 NULL, /* pSetDCOrg */
124 NULL, /* pSetDCPenColor*/
125 NULL, /* pSetDIBColorTable */
126 NULL, /* pSetDIBits */
127 MFDRV_SetDIBitsToDevice, /* pSetDIBitsToDevice */
128 NULL, /* pSetDeviceClipping */
129 NULL, /* pSetDeviceGammaRamp */
130 MFDRV_SetMapMode, /* pSetMapMode */
131 MFDRV_SetMapperFlags, /* pSetMapperFlags */
132 MFDRV_SetPixel, /* pSetPixel */
133 NULL, /* pSetPixelFormat */
134 MFDRV_SetPolyFillMode, /* pSetPolyFillMode */
135 MFDRV_SetROP2, /* pSetROP2 */
136 MFDRV_SetRelAbs, /* pSetRelAbs */
137 MFDRV_SetStretchBltMode, /* pSetStretchBltMode */
138 MFDRV_SetTextAlign, /* pSetTextAlign */
139 MFDRV_SetTextCharacterExtra, /* pSetTextCharacterExtra */
140 MFDRV_SetTextColor, /* pSetTextColor */
141 MFDRV_SetTextJustification, /* pSetTextJustification */
142 MFDRV_SetViewportExt, /* pSetViewportExt */
143 MFDRV_SetViewportOrg, /* pSetViewportOrg */
144 MFDRV_SetWindowExt, /* pSetWindowExt */
145 MFDRV_SetWindowOrg, /* pSetWindowOrg */
146 NULL, /* pSetWorldTransform */
147 NULL, /* pStartDoc */
148 NULL, /* pStartPage */
149 MFDRV_StretchBlt, /* pStretchBlt */
150 MFDRV_StretchDIBits, /* pStretchDIBits */
151 MFDRV_StrokeAndFillPath, /* pStrokeAndFillPath */
152 MFDRV_StrokePath, /* pStrokePath */
153 NULL, /* pSwapBuffers */
154 NULL, /* pUnrealizePalette */
155 MFDRV_WidenPath /* pWidenPath */
156 };
157
158
159
160 /**********************************************************************
161 * MFDRV_AllocMetaFile
162 */
163 static DC *MFDRV_AllocMetaFile(void)
164 {
165 DC *dc;
166 METAFILEDRV_PDEVICE *physDev;
167
168 if (!(dc = DC_AllocDC( &MFDRV_Funcs, METAFILE_DC_MAGIC ))) return NULL;
169
170 physDev = HeapAlloc(GetProcessHeap(),0,sizeof(*physDev));
171 if (!physDev)
172 {
173 GDI_FreeObject( dc->hSelf, dc );
174 return NULL;
175 }
176 dc->physDev = (PHYSDEV)physDev;
177 physDev->hdc = dc->hSelf;
178 physDev->dc = dc;
179
180 if (!(physDev->mh = HeapAlloc( GetProcessHeap(), 0, sizeof(*physDev->mh) )))
181 {
182 HeapFree( GetProcessHeap(), 0, physDev );
183 GDI_FreeObject( dc->hSelf, dc );
184 return NULL;
185 }
186
187 physDev->handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, HANDLE_LIST_INC * sizeof(physDev->handles[0]));
188 physDev->handles_size = HANDLE_LIST_INC;
189 physDev->cur_handles = 0;
190
191 physDev->hFile = 0;
192
193 physDev->mh->mtHeaderSize = sizeof(METAHEADER) / sizeof(WORD);
194 physDev->mh->mtVersion = 0x0300;
195 physDev->mh->mtSize = physDev->mh->mtHeaderSize;
196 physDev->mh->mtNoObjects = 0;
197 physDev->mh->mtMaxRecord = 0;
198 physDev->mh->mtNoParameters = 0;
199
200 return dc;
201 }
202
203
204 /**********************************************************************
205 * MFDRV_DeleteDC
206 */
207 static BOOL MFDRV_DeleteDC( PHYSDEV dev )
208 {
209 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
210 DC *dc = physDev->dc;
211 DWORD index;
212
213 HeapFree( GetProcessHeap(), 0, physDev->mh );
214 for(index = 0; index < physDev->handles_size; index++)
215 if(physDev->handles[index])
216 GDI_hdc_not_using_object(physDev->handles[index], physDev->hdc);
217 HeapFree( GetProcessHeap(), 0, physDev->handles );
218 HeapFree( GetProcessHeap(), 0, physDev );
219 dc->physDev = NULL;
220 GDI_FreeObject( dc->hSelf, dc );
221 return TRUE;
222 }
223
224
225 /**********************************************************************
226 * CreateMetaFileW (GDI32.@)
227 *
228 * Create a new DC and associate it with a metafile. Pass a filename
229 * to create a disk-based metafile, NULL to create a memory metafile.
230 *
231 * PARAMS
232 * filename [I] Filename of disk metafile
233 *
234 * RETURNS
235 * A handle to the metafile DC if successful, NULL on failure.
236 */
237 HDC WINAPI CreateMetaFileW( LPCWSTR filename )
238 {
239 HDC ret;
240 DC *dc;
241 METAFILEDRV_PDEVICE *physDev;
242 HANDLE hFile;
243
244 TRACE("%s\n", debugstr_w(filename) );
245
246 if (!(dc = MFDRV_AllocMetaFile())) return 0;
247 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
248
249 if (filename) /* disk based metafile */
250 {
251 physDev->mh->mtType = METAFILE_DISK;
252 if ((hFile = CreateFileW(filename, GENERIC_WRITE, 0, NULL,
253 CREATE_ALWAYS, 0, 0)) == INVALID_HANDLE_VALUE) {
254 MFDRV_DeleteDC( dc->physDev );
255 return 0;
256 }
257 if (!WriteFile( hFile, physDev->mh, sizeof(*physDev->mh), NULL,
258 NULL )) {
259 MFDRV_DeleteDC( dc->physDev );
260 return 0;
261 }
262 physDev->hFile = hFile;
263
264 /* Grow METAHEADER to include filename */
265 physDev->mh = MF_CreateMetaHeaderDisk(physDev->mh, filename, TRUE);
266 }
267 else /* memory based metafile */
268 physDev->mh->mtType = METAFILE_MEMORY;
269
270 TRACE("returning %p\n", dc->hSelf);
271 ret = dc->hSelf;
272 GDI_ReleaseObj( dc->hSelf );
273 return ret;
274 }
275
276 /**********************************************************************
277 * CreateMetaFileA (GDI32.@)
278 *
279 * See CreateMetaFileW.
280 */
281 HDC WINAPI CreateMetaFileA(LPCSTR filename)
282 {
283 LPWSTR filenameW;
284 DWORD len;
285 HDC hReturnDC;
286
287 if (!filename) return CreateMetaFileW(NULL);
288
289 len = MultiByteToWideChar( CP_ACP, 0, filename, -1, NULL, 0 );
290 filenameW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
291 MultiByteToWideChar( CP_ACP, 0, filename, -1, filenameW, len );
292
293 hReturnDC = CreateMetaFileW(filenameW);
294
295 HeapFree( GetProcessHeap(), 0, filenameW );
296
297 return hReturnDC;
298 }
299
300
301 /**********************************************************************
302 * MFDRV_CloseMetaFile
303 */
304 static DC *MFDRV_CloseMetaFile( HDC hdc )
305 {
306 DC *dc;
307 METAFILEDRV_PDEVICE *physDev;
308
309 TRACE("(%p)\n", hdc );
310
311 if (!(dc = (DC *) GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC ))) return 0;
312 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
313
314 /* Construct the end of metafile record - this is documented
315 * in SDK Knowledgebase Q99334.
316 */
317
318 if (!MFDRV_MetaParam0(dc->physDev, META_EOF))
319 {
320 MFDRV_DeleteDC( dc->physDev );
321 return 0;
322 }
323
324 if (physDev->mh->mtType == METAFILE_DISK) /* disk based metafile */
325 {
326 if (SetFilePointer(physDev->hFile, 0, NULL, FILE_BEGIN) != 0) {
327 MFDRV_DeleteDC( dc->physDev );
328 return 0;
329 }
330
331 physDev->mh->mtType = METAFILE_MEMORY; /* This is what windows does */
332 if (!WriteFile(physDev->hFile, (LPSTR)physDev->mh,
333 sizeof(*physDev->mh), NULL, NULL)) {
334 MFDRV_DeleteDC( dc->physDev );
335 return 0;
336 }
337 CloseHandle(physDev->hFile);
338 physDev->mh->mtType = METAFILE_DISK;
339 }
340
341 return dc;
342 }
343
344 /******************************************************************
345 * MF_Create_HMETATFILE16
346 *
347 * Creates a HMETAFILE16 object from a METAHEADER
348 *
349 * HMETAFILE16s are Global memory handles.
350 */
351 HMETAFILE16 MF_Create_HMETAFILE16(METAHEADER *mh)
352 {
353 HMETAFILE16 hmf;
354 DWORD size = mh->mtSize * sizeof(WORD);
355
356 hmf = GlobalAlloc16(GMEM_MOVEABLE, size);
357 if(hmf)
358 {
359 METAHEADER *mh_dest = GlobalLock16(hmf);
360 memcpy(mh_dest, mh, size);
361 GlobalUnlock16(hmf);
362 }
363 HeapFree(GetProcessHeap(), 0, mh);
364 return hmf;
365 }
366
367 /******************************************************************
368 * CloseMetaFile (GDI.126)
369 *
370 * PARAMS
371 * hdc [I] Metafile DC to close
372 */
373 HMETAFILE16 WINAPI CloseMetaFile16(HDC16 hdc)
374 {
375 HMETAFILE16 hmf;
376 METAFILEDRV_PDEVICE *physDev;
377 DC *dc = MFDRV_CloseMetaFile(HDC_32(hdc));
378 if (!dc) return 0;
379 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
380
381 /* Now allocate a global handle for the metafile */
382
383 hmf = MF_Create_HMETAFILE16( physDev->mh );
384
385 physDev->mh = NULL; /* So it won't be deleted */
386 MFDRV_DeleteDC( dc->physDev );
387 return hmf;
388 }
389
390 /******************************************************************
391 * CloseMetaFile (GDI32.@)
392 *
393 * Stop recording graphics operations in metafile associated with
394 * hdc and retrieve metafile.
395 *
396 * PARAMS
397 * hdc [I] Metafile DC to close
398 *
399 * RETURNS
400 * Handle of newly created metafile on success, NULL on failure.
401 */
402 HMETAFILE WINAPI CloseMetaFile(HDC hdc)
403 {
404 HMETAFILE hmf;
405 METAFILEDRV_PDEVICE *physDev;
406 DC *dc = MFDRV_CloseMetaFile(hdc);
407 if (!dc) return 0;
408 physDev = (METAFILEDRV_PDEVICE *)dc->physDev;
409
410 /* Now allocate a global handle for the metafile */
411
412 hmf = MF_Create_HMETAFILE( physDev->mh );
413
414 physDev->mh = NULL; /* So it won't be deleted */
415 MFDRV_DeleteDC( dc->physDev );
416 return hmf;
417 }
418
419
420 /******************************************************************
421 * MFDRV_WriteRecord
422 *
423 * Warning: this function can change the pointer to the metafile header.
424 */
425 BOOL MFDRV_WriteRecord( PHYSDEV dev, METARECORD *mr, DWORD rlen)
426 {
427 DWORD len, size;
428 METAHEADER *mh;
429 METAFILEDRV_PDEVICE *physDev = (METAFILEDRV_PDEVICE *)dev;
430
431 switch(physDev->mh->mtType)
432 {
433 case METAFILE_MEMORY:
434 len = physDev->mh->mtSize * 2 + rlen;
435 /* reallocate memory if needed */
436 size = HeapSize( GetProcessHeap(), 0, physDev->mh );
437 if (len > size)
438 {
439 /*expand size*/
440 size += size / 2 + rlen;
441 mh = HeapReAlloc( GetProcessHeap(), 0, physDev->mh, size);
442 if (!mh) return FALSE;
443 physDev->mh = mh;
444 TRACE("Reallocated metafile: new size is %d\n",size);
445 }
446 memcpy((WORD *)physDev->mh + physDev->mh->mtSize, mr, rlen);
447 break;
448 case METAFILE_DISK:
449 TRACE("Writing record to disk\n");
450 if (!WriteFile(physDev->hFile, (char *)mr, rlen, NULL, NULL))
451 return FALSE;
452 break;
453 default:
454 ERR("Unknown metafile type %d\n", physDev->mh->mtType );
455 return FALSE;
456 }
457
458 physDev->mh->mtSize += rlen / 2;
459 physDev->mh->mtMaxRecord = max(physDev->mh->mtMaxRecord, rlen / 2);
460 return TRUE;
461 }
462
463
464 /******************************************************************
465 * MFDRV_MetaParam0
466 */
467
468 BOOL MFDRV_MetaParam0(PHYSDEV dev, short func)
469 {
470 char buffer[8];
471 METARECORD *mr = (METARECORD *)&buffer;
472
473 mr->rdSize = 3;
474 mr->rdFunction = func;
475 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
476 }
477
478
479 /******************************************************************
480 * MFDRV_MetaParam1
481 */
482 BOOL MFDRV_MetaParam1(PHYSDEV dev, short func, short param1)
483 {
484 char buffer[8];
485 METARECORD *mr = (METARECORD *)&buffer;
486
487 mr->rdSize = 4;
488 mr->rdFunction = func;
489 *(mr->rdParm) = param1;
490 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
491 }
492
493
494 /******************************************************************
495 * MFDRV_MetaParam2
496 */
497 BOOL MFDRV_MetaParam2(PHYSDEV dev, short func, short param1, short param2)
498 {
499 char buffer[10];
500 METARECORD *mr = (METARECORD *)&buffer;
501
502 mr->rdSize = 5;
503 mr->rdFunction = func;
504 *(mr->rdParm) = param2;
505 *(mr->rdParm + 1) = param1;
506 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
507 }
508
509
510 /******************************************************************
511 * MFDRV_MetaParam4
512 */
513
514 BOOL MFDRV_MetaParam4(PHYSDEV dev, short func, short param1, short param2,
515 short param3, short param4)
516 {
517 char buffer[14];
518 METARECORD *mr = (METARECORD *)&buffer;
519
520 mr->rdSize = 7;
521 mr->rdFunction = func;
522 *(mr->rdParm) = param4;
523 *(mr->rdParm + 1) = param3;
524 *(mr->rdParm + 2) = param2;
525 *(mr->rdParm + 3) = param1;
526 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
527 }
528
529
530 /******************************************************************
531 * MFDRV_MetaParam6
532 */
533
534 BOOL MFDRV_MetaParam6(PHYSDEV dev, short func, short param1, short param2,
535 short param3, short param4, short param5, short param6)
536 {
537 char buffer[18];
538 METARECORD *mr = (METARECORD *)&buffer;
539
540 mr->rdSize = 9;
541 mr->rdFunction = func;
542 *(mr->rdParm) = param6;
543 *(mr->rdParm + 1) = param5;
544 *(mr->rdParm + 2) = param4;
545 *(mr->rdParm + 3) = param3;
546 *(mr->rdParm + 4) = param2;
547 *(mr->rdParm + 5) = param1;
548 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
549 }
550
551
552 /******************************************************************
553 * MFDRV_MetaParam8
554 */
555 BOOL MFDRV_MetaParam8(PHYSDEV dev, short func, short param1, short param2,
556 short param3, short param4, short param5,
557 short param6, short param7, short param8)
558 {
559 char buffer[22];
560 METARECORD *mr = (METARECORD *)&buffer;
561
562 mr->rdSize = 11;
563 mr->rdFunction = func;
564 *(mr->rdParm) = param8;
565 *(mr->rdParm + 1) = param7;
566 *(mr->rdParm + 2) = param6;
567 *(mr->rdParm + 3) = param5;
568 *(mr->rdParm + 4) = param4;
569 *(mr->rdParm + 5) = param3;
570 *(mr->rdParm + 6) = param2;
571 *(mr->rdParm + 7) = param1;
572 return MFDRV_WriteRecord( dev, mr, mr->rdSize * 2);
573 }
574
575
576 /**********************************************************************
577 * MFDRV_ExtEscape
578 */
579 INT MFDRV_ExtEscape( PHYSDEV dev, INT nEscape, INT cbInput, LPCVOID in_data,
580 INT cbOutput, LPVOID out_data )
581 {
582 METARECORD *mr;
583 DWORD len;
584 INT ret;
585
586 if (cbOutput) return 0; /* escapes that require output cannot work in metafiles */
587
588 len = sizeof(*mr) + sizeof(WORD) + ((cbInput + 1) & ~1);
589 mr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
590 mr->rdSize = len / 2;
591 mr->rdFunction = META_ESCAPE;
592 mr->rdParm[0] = nEscape;
593 mr->rdParm[1] = cbInput;
594 memcpy(&(mr->rdParm[2]), in_data, cbInput);
595 ret = MFDRV_WriteRecord( dev, mr, len);
596 HeapFree(GetProcessHeap(), 0, mr);
597 return ret;
598 }
599
600
601 /******************************************************************
602 * MFDRV_GetDeviceCaps
603 *
604 *A very simple implementation that returns DT_METAFILE
605 */
606 INT MFDRV_GetDeviceCaps(PHYSDEV dev, INT cap)
607 {
608 switch(cap)
609 {
610 case TECHNOLOGY:
611 return DT_METAFILE;
612 case TEXTCAPS:
613 return 0;
614 default:
615 TRACE(" unsupported capability %d, will return 0\n", cap );
616 }
617 return 0;
618 }
useful hacks and other patches not (yet) suitable for mainline