source: trunk/include/os2wrap.h@ 57

Last change on this file since 57 was 48, checked in by sandervl, 26 years ago

* empty log message *
File size: 178.6 KB
Line 
1#ifndef __OS2WRAP_H__
2#define __OS2WRAP_H__
3
4#include <os2sel.h>
5
6#ifdef INCL_DOSMEMMGR
7inline ULONG APIENTRY DosAllocMem(PPVOID a, ULONG b, ULONG c)
8{
9 ULONG yyrc;
10 USHORT sel = GetFS();
11
12 yyrc = DosAllocMem(a, b, c);
13 SetFS(sel);
14
15 return yyrc;
16}
17
18inline ULONG APIENTRY DosAllocSharedMem(PPVOID a, PCSZ b, ULONG c, ULONG d)
19{
20 ULONG yyrc;
21 USHORT sel = GetFS();
22
23 yyrc = DosAllocSharedMem(a, b, c, d);
24 SetFS(sel);
25
26 return yyrc;
27}
28
29inline ULONG APIENTRY DosFreeMem(PVOID a)
30{
31 ULONG yyrc;
32 USHORT sel = GetFS();
33
34 yyrc = DosFreeMem(a);
35 SetFS(sel);
36
37 return yyrc;
38}
39
40inline ULONG APIENTRY DosGetNamedSharedMem(PPVOID a, PCSZ b, ULONG c)
41{
42 ULONG yyrc;
43 USHORT sel = GetFS();
44
45 yyrc = DosGetNamedSharedMem(a, b, c);
46 SetFS(sel);
47
48 return yyrc;
49}
50
51inline ULONG APIENTRY DosGetSharedMem(PVOID a, ULONG b)
52{
53 ULONG yyrc;
54 USHORT sel = GetFS();
55
56 yyrc = DosGetSharedMem(a, b);
57 SetFS(sel);
58
59 return yyrc;
60}
61
62inline ULONG APIENTRY DosGiveSharedMem(PVOID a, PID b, ULONG c)
63{
64 ULONG yyrc;
65 USHORT sel = GetFS();
66
67 yyrc = DosGiveSharedMem(a, b, c);
68 SetFS(sel);
69
70 return yyrc;
71}
72
73inline ULONG APIENTRY DosQueryMem(PVOID a, PULONG b, PULONG c)
74{
75 ULONG yyrc;
76 USHORT sel = GetFS();
77
78 yyrc = DosQueryMem(a, b, c);
79 SetFS(sel);
80
81 return yyrc;
82}
83
84inline ULONG APIENTRY DosSetMem(PVOID a, ULONG b, ULONG c)
85{
86 ULONG yyrc;
87 USHORT sel = GetFS();
88
89 yyrc = DosSetMem(a, b, c);
90 SetFS(sel);
91
92 return yyrc;
93}
94
95inline ULONG APIENTRY DosSubAllocMem(PVOID a, PPVOID b, ULONG c)
96{
97 ULONG yyrc;
98 USHORT sel = GetFS();
99
100 yyrc = DosSubAllocMem(a, b, c);
101 SetFS(sel);
102
103 return yyrc;
104}
105
106inline ULONG APIENTRY DosSubFreeMem(PVOID a, PVOID b, ULONG c)
107{
108 ULONG yyrc;
109 USHORT sel = GetFS();
110
111 yyrc = DosSubFreeMem(a, b, c);
112 SetFS(sel);
113
114 return yyrc;
115}
116
117inline ULONG APIENTRY DosSubSetMem(PVOID a, ULONG b, ULONG c)
118{
119 ULONG yyrc;
120 USHORT sel = GetFS();
121
122 yyrc = DosSubSetMem(a, b, c);
123 SetFS(sel);
124
125 return yyrc;
126}
127
128inline ULONG APIENTRY DosSubUnsetMem(PVOID a)
129{
130 ULONG yyrc;
131 USHORT sel = GetFS();
132
133 yyrc = DosSubUnsetMem(a);
134 SetFS(sel);
135
136 return yyrc;
137}
138
139#endif
140#ifdef INCL_DOSFILEMGR
141inline ULONG APIENTRY DosCancelLockRequest(HFILE a, CONST FILELOCK *b)
142{
143 ULONG yyrc;
144 USHORT sel = GetFS();
145
146 yyrc = DosCancelLockRequest(a, b);
147 SetFS(sel);
148
149 return yyrc;
150}
151
152inline ULONG APIENTRY DosClose(HFILE a)
153{
154 ULONG yyrc;
155 USHORT sel = GetFS();
156
157 yyrc = DosClose(a);
158 SetFS(sel);
159
160 return yyrc;
161}
162
163inline ULONG APIENTRY DosCopy(PCSZ a, PCSZ b, ULONG c)
164{
165 ULONG yyrc;
166 USHORT sel = GetFS();
167
168 yyrc = DosCopy(a, b, c);
169 SetFS(sel);
170
171 return yyrc;
172}
173
174inline ULONG APIENTRY DosCreateDir(PCSZ a, PEAOP2 b)
175{
176 ULONG yyrc;
177 USHORT sel = GetFS();
178
179 yyrc = DosCreateDir(a, b);
180 SetFS(sel);
181
182 return yyrc;
183}
184
185inline ULONG APIENTRY DosDelete(PCSZ a)
186{
187 ULONG yyrc;
188 USHORT sel = GetFS();
189
190 yyrc = DosDelete(a);
191 SetFS(sel);
192
193 return yyrc;
194}
195
196inline ULONG APIENTRY DosDeleteDir(PCSZ a)
197{
198 ULONG yyrc;
199 USHORT sel = GetFS();
200
201 yyrc = DosDeleteDir(a);
202 SetFS(sel);
203
204 return yyrc;
205}
206
207inline ULONG APIENTRY DosDupHandle(HFILE a, PHFILE b)
208{
209 ULONG yyrc;
210 USHORT sel = GetFS();
211
212 yyrc = DosDupHandle(a, b);
213 SetFS(sel);
214
215 return yyrc;
216}
217
218inline ULONG APIENTRY DosEditName(ULONG a, PCSZ b, PCSZ c, PBYTE d, ULONG e)
219{
220 ULONG yyrc;
221 USHORT sel = GetFS();
222
223 yyrc = DosEditName(a, b, c, d, e);
224 SetFS(sel);
225
226 return yyrc;
227}
228
229inline ULONG APIENTRY DosEnumAttribute(ULONG a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g)
230{
231 ULONG yyrc;
232 USHORT sel = GetFS();
233
234 yyrc = DosEnumAttribute(a, b, c, d, e, f, g);
235 SetFS(sel);
236
237 return yyrc;
238}
239
240inline ULONG APIENTRY DosFindClose(HDIR a)
241{
242 ULONG yyrc;
243 USHORT sel = GetFS();
244
245 yyrc = DosFindClose(a);
246 SetFS(sel);
247
248 return yyrc;
249}
250
251inline ULONG APIENTRY DosFindFirst(PCSZ a, PHDIR b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g)
252{
253 ULONG yyrc;
254 USHORT sel = GetFS();
255
256 yyrc = DosFindFirst(a, b, c, d, e, f, g);
257 SetFS(sel);
258
259 return yyrc;
260}
261
262inline ULONG APIENTRY DosFindNext(HDIR a, PVOID b, ULONG c, PULONG d)
263{
264 ULONG yyrc;
265 USHORT sel = GetFS();
266
267 yyrc = DosFindNext(a, b, c, d);
268 SetFS(sel);
269
270 return yyrc;
271}
272
273inline ULONG APIENTRY DosForceDelete(PCSZ a)
274{
275 ULONG yyrc;
276 USHORT sel = GetFS();
277
278 yyrc = DosForceDelete(a);
279 SetFS(sel);
280
281 return yyrc;
282}
283
284inline ULONG APIENTRY DosFSAttach(PCSZ a, PCSZ b, CONST VOID *c, ULONG d, ULONG e)
285{
286 ULONG yyrc;
287 USHORT sel = GetFS();
288
289 yyrc = DosFSAttach(a, b, c, d, e);
290 SetFS(sel);
291
292 return yyrc;
293}
294
295inline ULONG APIENTRY DosFSCtl(PVOID a, ULONG b, PULONG c, PVOID d, ULONG e, PULONG f, ULONG g, PCSZ h, HFILE i, ULONG j)
296{
297 ULONG yyrc;
298 USHORT sel = GetFS();
299
300 yyrc = DosFSCtl(a, b, c, d, e, f, g, h, i, j);
301 SetFS(sel);
302
303 return yyrc;
304}
305
306inline ULONG APIENTRY DosMove(PCSZ a, PCSZ b)
307{
308 ULONG yyrc;
309 USHORT sel = GetFS();
310
311 yyrc = DosMove(a, b);
312 SetFS(sel);
313
314 return yyrc;
315}
316
317inline ULONG APIENTRY DosOpen(PCSZ a, PHFILE b, PULONG c, ULONG d, ULONG e, ULONG f, ULONG g, PEAOP2 h)
318{
319 ULONG yyrc;
320 USHORT sel = GetFS();
321
322 yyrc = DosOpen(a, b, c, d, e, f, g, h);
323 SetFS(sel);
324
325 return yyrc;
326}
327
328inline ULONG APIENTRY DosProtectClose(HFILE a, FHLOCK b)
329{
330 ULONG yyrc;
331 USHORT sel = GetFS();
332
333 yyrc = DosProtectClose(a, b);
334 SetFS(sel);
335
336 return yyrc;
337}
338
339inline ULONG APIENTRY DosProtectEnumAttribute(ULONG a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g, FHLOCK h)
340{
341 ULONG yyrc;
342 USHORT sel = GetFS();
343
344 yyrc = DosProtectEnumAttribute(a, b, c, d, e, f, g, h);
345 SetFS(sel);
346
347 return yyrc;
348}
349
350inline ULONG APIENTRY DosProtectOpen(PCSZ a, PHFILE b, PULONG c, ULONG d, ULONG e, ULONG f, ULONG g, PEAOP2 h, PFHLOCK i)
351{
352 ULONG yyrc;
353 USHORT sel = GetFS();
354
355 yyrc = DosProtectOpen(a, b, c, d, e, f, g, h, i);
356 SetFS(sel);
357
358 return yyrc;
359}
360
361inline ULONG APIENTRY DosProtectQueryFHState(HFILE a, PULONG b, FHLOCK c)
362{
363 ULONG yyrc;
364 USHORT sel = GetFS();
365
366 yyrc = DosProtectQueryFHState(a, b, c);
367 SetFS(sel);
368
369 return yyrc;
370}
371
372inline ULONG APIENTRY DosProtectQueryFileInfo(HFILE a, ULONG b, PVOID c, ULONG d, FHLOCK e)
373{
374 ULONG yyrc;
375 USHORT sel = GetFS();
376
377 yyrc = DosProtectQueryFileInfo(a, b, c, d, e);
378 SetFS(sel);
379
380 return yyrc;
381}
382
383inline ULONG APIENTRY DosProtectRead(HFILE a, PVOID b, ULONG c, PULONG d, FHLOCK e)
384{
385 ULONG yyrc;
386 USHORT sel = GetFS();
387
388 yyrc = DosProtectRead(a, b, c, d, e);
389 SetFS(sel);
390
391 return yyrc;
392}
393
394inline ULONG APIENTRY DosProtectSetFHState(HFILE a, ULONG b, FHLOCK c)
395{
396 ULONG yyrc;
397 USHORT sel = GetFS();
398
399 yyrc = DosProtectSetFHState(a, b, c);
400 SetFS(sel);
401
402 return yyrc;
403}
404
405inline ULONG APIENTRY DosProtectSetFileInfo(HFILE a, ULONG b, PVOID c, ULONG d, FHLOCK e)
406{
407 ULONG yyrc;
408 USHORT sel = GetFS();
409
410 yyrc = DosProtectSetFileInfo(a, b, c, d, e);
411 SetFS(sel);
412
413 return yyrc;
414}
415
416inline ULONG APIENTRY DosProtectSetFileLocks(HFILE a, CONST FILELOCK *b, CONST FILELOCK *c, ULONG d, ULONG e, FHLOCK f)
417{
418 ULONG yyrc;
419 USHORT sel = GetFS();
420
421 yyrc = DosProtectSetFileLocks(a, b, c, d, e, f);
422 SetFS(sel);
423
424 return yyrc;
425}
426
427inline ULONG APIENTRY DosProtectSetFilePtr(HFILE a, LONG b, ULONG c, PULONG d, FHLOCK e)
428{
429 ULONG yyrc;
430 USHORT sel = GetFS();
431
432 yyrc = DosProtectSetFilePtr(a, b, c, d, e);
433 SetFS(sel);
434
435 return yyrc;
436}
437
438inline ULONG APIENTRY DosProtectSetFileSize(HFILE a, ULONG b, FHLOCK c)
439{
440 ULONG yyrc;
441 USHORT sel = GetFS();
442
443 yyrc = DosProtectSetFileSize(a, b, c);
444 SetFS(sel);
445
446 return yyrc;
447}
448
449inline ULONG APIENTRY DosProtectWrite(HFILE a, PVOID b, ULONG c, PULONG d, FHLOCK e)
450{
451 ULONG yyrc;
452 USHORT sel = GetFS();
453
454 yyrc = DosProtectWrite(a, b, c, d, e);
455 SetFS(sel);
456
457 return yyrc;
458}
459
460inline ULONG APIENTRY DosQueryCurrentDir(ULONG a, PBYTE b, PULONG c)
461{
462 ULONG yyrc;
463 USHORT sel = GetFS();
464
465 yyrc = DosQueryCurrentDir(a, b, c);
466 SetFS(sel);
467
468 return yyrc;
469}
470
471inline ULONG APIENTRY DosQueryCurrentDisk(PULONG a, PULONG b)
472{
473 ULONG yyrc;
474 USHORT sel = GetFS();
475
476 yyrc = DosQueryCurrentDisk(a, b);
477 SetFS(sel);
478
479 return yyrc;
480}
481
482inline ULONG APIENTRY DosQueryFHState(HFILE a, PULONG b)
483{
484 ULONG yyrc;
485 USHORT sel = GetFS();
486
487 yyrc = DosQueryFHState(a, b);
488 SetFS(sel);
489
490 return yyrc;
491}
492
493inline ULONG APIENTRY DosQueryFileInfo(HFILE a, ULONG b, PVOID c, ULONG d)
494{
495 ULONG yyrc;
496 USHORT sel = GetFS();
497
498 yyrc = DosQueryFileInfo(a, b, c, d);
499 SetFS(sel);
500
501 return yyrc;
502}
503
504inline ULONG APIENTRY DosQueryFSAttach(PCSZ a, ULONG b, ULONG c, PFSQBUFFER2 d, PULONG e)
505{
506 ULONG yyrc;
507 USHORT sel = GetFS();
508
509 yyrc = DosQueryFSAttach(a, b, c, d, e);
510 SetFS(sel);
511
512 return yyrc;
513}
514
515inline ULONG APIENTRY DosQueryFSInfo(ULONG a, ULONG b, PVOID c, ULONG d)
516{
517 ULONG yyrc;
518 USHORT sel = GetFS();
519
520 yyrc = DosQueryFSInfo(a, b, c, d);
521 SetFS(sel);
522
523 return yyrc;
524}
525
526inline ULONG APIENTRY DosQueryHType(HFILE a, PULONG b, PULONG c)
527{
528 ULONG yyrc;
529 USHORT sel = GetFS();
530
531 yyrc = DosQueryHType(a, b, c);
532 SetFS(sel);
533
534 return yyrc;
535}
536
537inline ULONG APIENTRY DosQueryPathInfo(PCSZ a, ULONG b, PVOID c, ULONG d)
538{
539 ULONG yyrc;
540 USHORT sel = GetFS();
541
542 yyrc = DosQueryPathInfo(a, b, c, d);
543 SetFS(sel);
544
545 return yyrc;
546}
547
548inline ULONG APIENTRY DosQueryVerify(PBOOL32 a)
549{
550 ULONG yyrc;
551 USHORT sel = GetFS();
552
553 yyrc = DosQueryVerify(a);
554 SetFS(sel);
555
556 return yyrc;
557}
558
559inline ULONG APIENTRY DosRead(HFILE a, PVOID b, ULONG c, PULONG d)
560{
561 ULONG yyrc;
562 USHORT sel = GetFS();
563
564 yyrc = DosRead(a, b, c, d);
565 SetFS(sel);
566
567 return yyrc;
568}
569
570inline ULONG APIENTRY DosResetBuffer(HFILE a)
571{
572 ULONG yyrc;
573 USHORT sel = GetFS();
574
575 yyrc = DosResetBuffer(a);
576 SetFS(sel);
577
578 return yyrc;
579}
580
581inline ULONG APIENTRY DosSetCurrentDir(PCSZ a)
582{
583 ULONG yyrc;
584 USHORT sel = GetFS();
585
586 yyrc = DosSetCurrentDir(a);
587 SetFS(sel);
588
589 return yyrc;
590}
591
592inline ULONG APIENTRY DosSetDefaultDisk(ULONG a)
593{
594 ULONG yyrc;
595 USHORT sel = GetFS();
596
597 yyrc = DosSetDefaultDisk(a);
598 SetFS(sel);
599
600 return yyrc;
601}
602
603inline ULONG APIENTRY DosSetFHState(HFILE a, ULONG b)
604{
605 ULONG yyrc;
606 USHORT sel = GetFS();
607
608 yyrc = DosSetFHState(a, b);
609 SetFS(sel);
610
611 return yyrc;
612}
613
614inline ULONG APIENTRY DosSetFileInfo(HFILE a, ULONG b, PVOID c, ULONG d)
615{
616 ULONG yyrc;
617 USHORT sel = GetFS();
618
619 yyrc = DosSetFileInfo(a, b, c, d);
620 SetFS(sel);
621
622 return yyrc;
623}
624
625inline ULONG APIENTRY DosSetFileLocks(HFILE a, CONST FILELOCK *b, CONST FILELOCK *c, ULONG d, ULONG e)
626{
627 ULONG yyrc;
628 USHORT sel = GetFS();
629
630 yyrc = DosSetFileLocks(a, b, c, d, e);
631 SetFS(sel);
632
633 return yyrc;
634}
635
636inline ULONG APIENTRY DosSetFilePtr(HFILE a, LONG b, ULONG c, PULONG d)
637{
638 ULONG yyrc;
639 USHORT sel = GetFS();
640
641 yyrc = DosSetFilePtr(a, b, c, d);
642 SetFS(sel);
643
644 return yyrc;
645}
646
647inline ULONG APIENTRY DosSetFileSize(HFILE a, ULONG b)
648{
649 ULONG yyrc;
650 USHORT sel = GetFS();
651
652 yyrc = DosSetFileSize(a, b);
653 SetFS(sel);
654
655 return yyrc;
656}
657
658inline ULONG APIENTRY DosSetFSInfo(ULONG a, ULONG b, PVOID c, ULONG d)
659{
660 ULONG yyrc;
661 USHORT sel = GetFS();
662
663 yyrc = DosSetFSInfo(a, b, c, d);
664 SetFS(sel);
665
666 return yyrc;
667}
668
669inline ULONG APIENTRY DosSetMaxFH(ULONG a)
670{
671 ULONG yyrc;
672 USHORT sel = GetFS();
673
674 yyrc = DosSetMaxFH(a);
675 SetFS(sel);
676
677 return yyrc;
678}
679
680inline ULONG APIENTRY DosSetPathInfo(PCSZ a, ULONG b, PVOID c, ULONG d, ULONG e)
681{
682 ULONG yyrc;
683 USHORT sel = GetFS();
684
685 yyrc = DosSetPathInfo(a, b, c, d, e);
686 SetFS(sel);
687
688 return yyrc;
689}
690
691inline ULONG APIENTRY DosSetRelMaxFH(PLONG a, PULONG b)
692{
693 ULONG yyrc;
694 USHORT sel = GetFS();
695
696 yyrc = DosSetRelMaxFH(a, b);
697 SetFS(sel);
698
699 return yyrc;
700}
701
702inline ULONG APIENTRY DosSetVerify(BOOL32 a)
703{
704 ULONG yyrc;
705 USHORT sel = GetFS();
706
707 yyrc = DosSetVerify(a);
708 SetFS(sel);
709
710 return yyrc;
711}
712
713inline ULONG APIENTRY DosShutdown(ULONG a)
714{
715 ULONG yyrc;
716 USHORT sel = GetFS();
717
718 yyrc = DosShutdown(a);
719 SetFS(sel);
720
721 return yyrc;
722}
723
724inline ULONG APIENTRY DosWrite(HFILE a, PVOID b, ULONG c, PULONG d)
725{
726 ULONG yyrc;
727 USHORT sel = GetFS();
728
729 yyrc = DosWrite(a, b, c, d);
730 SetFS(sel);
731
732 return yyrc;
733}
734
735#endif
736#ifdef INCL_DOSMISC
737inline ULONG APIENTRY DosSearchPath(ULONG a, PCSZ b, PCSZ c, PBYTE d, ULONG e)
738{
739 ULONG yyrc;
740 USHORT sel = GetFS();
741
742 yyrc = DosSearchPath(a, b, c, d, e);
743 SetFS(sel);
744
745 return yyrc;
746}
747
748#endif
749#ifdef INCL_DOSDEVICES
750inline ULONG APIENTRY DosDevConfig(PVOID a, ULONG b)
751{
752 ULONG yyrc;
753 USHORT sel = GetFS();
754
755 yyrc = DosDevConfig(a, b);
756 SetFS(sel);
757
758 return yyrc;
759}
760
761inline ULONG APIENTRY DosDevIOCtl(HFILE a, ULONG b, ULONG c, PVOID d, ULONG e, PULONG f, PVOID g, ULONG h, PULONG i)
762{
763 ULONG yyrc;
764 USHORT sel = GetFS();
765
766 yyrc = DosDevIOCtl(a, b, c, d, e, f, g, h, i);
767 SetFS(sel);
768
769 return yyrc;
770}
771
772inline ULONG APIENTRY DosPhysicalDisk(ULONG a, PVOID b, ULONG c, PVOID d, ULONG e)
773{
774 ULONG yyrc;
775 USHORT sel = GetFS();
776
777 yyrc = DosPhysicalDisk(a, b, c, d, e);
778 SetFS(sel);
779
780 return yyrc;
781}
782
783#endif
784#ifdef INCL_DOSNLS
785inline ULONG APIENTRY DosMapCase(ULONG a, CONST COUNTRYCODE *b, PCHAR c)
786{
787 ULONG yyrc;
788 USHORT sel = GetFS();
789
790 yyrc = DosMapCase(a, b, c);
791 SetFS(sel);
792
793 return yyrc;
794}
795
796inline ULONG APIENTRY DosQueryCollate(ULONG a, CONST COUNTRYCODE *b, PCHAR c, PULONG d)
797{
798 ULONG yyrc;
799 USHORT sel = GetFS();
800
801 yyrc = DosQueryCollate(a, b, c, d);
802 SetFS(sel);
803
804 return yyrc;
805}
806
807inline ULONG APIENTRY DosQueryCp(ULONG a, PULONG b, PULONG c)
808{
809 ULONG yyrc;
810 USHORT sel = GetFS();
811
812 yyrc = DosQueryCp(a, b, c);
813 SetFS(sel);
814
815 return yyrc;
816}
817
818inline ULONG APIENTRY DosQueryCtryInfo(ULONG a, PCOUNTRYCODE b, PCOUNTRYINFO c, PULONG d)
819{
820 ULONG yyrc;
821 USHORT sel = GetFS();
822
823 yyrc = DosQueryCtryInfo(a, b, c, d);
824 SetFS(sel);
825
826 return yyrc;
827}
828
829inline ULONG APIENTRY DosQueryDBCSEnv(ULONG a, PCOUNTRYCODE b, PCHAR c)
830{
831 ULONG yyrc;
832 USHORT sel = GetFS();
833
834 yyrc = DosQueryDBCSEnv(a, b, c);
835 SetFS(sel);
836
837 return yyrc;
838}
839
840inline ULONG APIENTRY DosSetProcessCp(ULONG a)
841{
842 ULONG yyrc;
843 USHORT sel = GetFS();
844
845 yyrc = DosSetProcessCp(a);
846 SetFS(sel);
847
848 return yyrc;
849}
850
851#endif
852#ifdef INCL_DOSMODULEMGR
853inline ULONG APIENTRY DosFreeModule(HMODULE a)
854{
855 ULONG yyrc;
856 USHORT sel = GetFS();
857
858 yyrc = DosFreeModule(a);
859 SetFS(sel);
860
861 return yyrc;
862}
863
864inline ULONG APIENTRY DosLoadModule(PSZ a, ULONG b, PCSZ c, PHMODULE d)
865{
866 ULONG yyrc;
867 USHORT sel = GetFS();
868
869 yyrc = DosLoadModule(a, b, c, d);
870 SetFS(sel);
871
872 return yyrc;
873}
874
875inline ULONG APIENTRY DosQueryModuleHandle(PCSZ a, PHMODULE b)
876{
877 ULONG yyrc;
878 USHORT sel = GetFS();
879
880 yyrc = DosQueryModuleHandle(a, b);
881 SetFS(sel);
882
883 return yyrc;
884}
885
886inline ULONG APIENTRY DosQueryModuleName(HMODULE a, ULONG b, PCHAR c)
887{
888 ULONG yyrc;
889 USHORT sel = GetFS();
890
891 yyrc = DosQueryModuleName(a, b, c);
892 SetFS(sel);
893
894 return yyrc;
895}
896
897inline ULONG APIENTRY DosQueryProcAddr(HMODULE a, ULONG b, PCSZ c, PFN *d)
898{
899 ULONG yyrc;
900 USHORT sel = GetFS();
901
902 yyrc = DosQueryProcAddr(a, b, c, d);
903 SetFS(sel);
904
905 return yyrc;
906}
907
908inline ULONG APIENTRY DosQueryProcType(HMODULE a, ULONG b, PCSZ c, PULONG d)
909{
910 ULONG yyrc;
911 USHORT sel = GetFS();
912
913 yyrc = DosQueryProcType(a, b, c, d);
914 SetFS(sel);
915
916 return yyrc;
917}
918
919#endif
920#ifdef INCL_DOSRESOURCES
921inline ULONG APIENTRY DosFreeResource(PVOID a)
922{
923 ULONG yyrc;
924 USHORT sel = GetFS();
925
926 yyrc = DosFreeResource(a);
927 SetFS(sel);
928
929 return yyrc;
930}
931
932inline ULONG APIENTRY DosGetResource(HMODULE a, ULONG b, ULONG c, PPVOID d)
933{
934 ULONG yyrc;
935 USHORT sel = GetFS();
936
937 yyrc = DosGetResource(a, b, c, d);
938 SetFS(sel);
939
940 return yyrc;
941}
942
943inline ULONG APIENTRY DosQueryResourceSize(HMODULE a, ULONG b, ULONG c, PULONG d)
944{
945 ULONG yyrc;
946 USHORT sel = GetFS();
947
948 yyrc = DosQueryResourceSize(a, b, c, d);
949 SetFS(sel);
950
951 return yyrc;
952}
953
954#endif
955#ifdef INCL_DOSPROCESS
956inline ULONG APIENTRY DosBeep(ULONG a, ULONG b)
957{
958 ULONG yyrc;
959 USHORT sel = GetFS();
960
961 yyrc = DosBeep(a, b);
962 SetFS(sel);
963
964 return yyrc;
965}
966
967inline VOID APIENTRY DosExit(ULONG a, ULONG b)
968{
969 USHORT sel = GetFS();
970
971 DosExit(a, b);
972 SetFS(sel);
973}
974
975inline ULONG APIENTRY DosAllocThreadLocalMemory(ULONG a, PULONG *b)
976{
977 ULONG yyrc;
978 USHORT sel = GetFS();
979
980 yyrc = DosAllocThreadLocalMemory(a, b);
981 SetFS(sel);
982
983 return yyrc;
984}
985
986inline ULONG APIENTRY DosCreateThread(PTID a, PFNTHREAD b, ULONG c, ULONG d, ULONG e)
987{
988 ULONG yyrc;
989 USHORT sel = GetFS();
990
991 yyrc = DosCreateThread(a, b, c, d, e);
992 SetFS(sel);
993
994 return yyrc;
995}
996
997inline ULONG APIENTRY DosEnterCritSec()
998{
999 ULONG yyrc;
1000 USHORT sel = GetFS();
1001
1002 yyrc = DosEnterCritSec();
1003 SetFS(sel);
1004
1005 return yyrc;
1006}
1007
1008inline ULONG APIENTRY DosExecPgm(PCHAR a, LONG b, ULONG c, PCSZ d, PCSZ e, PRESULTCODES f, PCSZ g)
1009{
1010 ULONG yyrc;
1011 USHORT sel = GetFS();
1012
1013 yyrc = DosExecPgm(a, b, c, d, e, f, g);
1014 SetFS(sel);
1015
1016 return yyrc;
1017}
1018
1019inline ULONG APIENTRY DosExitCritSec()
1020{
1021 ULONG yyrc;
1022 USHORT sel = GetFS();
1023
1024 yyrc = DosExitCritSec();
1025 SetFS(sel);
1026
1027 return yyrc;
1028}
1029
1030inline ULONG APIENTRY DosExitList(ULONG a, PFNEXITLIST b)
1031{
1032 ULONG yyrc;
1033 USHORT sel = GetFS();
1034
1035 yyrc = DosExitList(a, b);
1036 SetFS(sel);
1037
1038 return yyrc;
1039}
1040
1041inline ULONG APIENTRY DosFreeThreadLocalMemory(ULONG *a)
1042{
1043 ULONG yyrc;
1044 USHORT sel = GetFS();
1045
1046 yyrc = DosFreeThreadLocalMemory(a);
1047 SetFS(sel);
1048
1049 return yyrc;
1050}
1051
1052inline ULONG APIENTRY DosGetInfoBlocks(PTIB *a, PPIB *b)
1053{
1054 ULONG yyrc;
1055 USHORT sel = GetFS();
1056
1057 yyrc = DosGetInfoBlocks(a, b);
1058 SetFS(sel);
1059
1060 return yyrc;
1061}
1062
1063inline ULONG APIENTRY DosKillProcess(ULONG a, PID b)
1064{
1065 ULONG yyrc;
1066 USHORT sel = GetFS();
1067
1068 yyrc = DosKillProcess(a, b);
1069 SetFS(sel);
1070
1071 return yyrc;
1072}
1073
1074inline ULONG APIENTRY DosKillThread(TID a)
1075{
1076 ULONG yyrc;
1077 USHORT sel = GetFS();
1078
1079 yyrc = DosKillThread(a);
1080 SetFS(sel);
1081
1082 return yyrc;
1083}
1084
1085inline ULONG APIENTRY DosResumeThread(TID a)
1086{
1087 ULONG yyrc;
1088 USHORT sel = GetFS();
1089
1090 yyrc = DosResumeThread(a);
1091 SetFS(sel);
1092
1093 return yyrc;
1094}
1095
1096inline ULONG APIENTRY DosSetPriority(ULONG a, ULONG b, LONG c, ULONG d)
1097{
1098 ULONG yyrc;
1099 USHORT sel = GetFS();
1100
1101 yyrc = DosSetPriority(a, b, c, d);
1102 SetFS(sel);
1103
1104 return yyrc;
1105}
1106
1107inline ULONG APIENTRY DosSleep(ULONG a)
1108{
1109 ULONG yyrc;
1110 USHORT sel = GetFS();
1111
1112 yyrc = DosSleep(a);
1113 SetFS(sel);
1114
1115 return yyrc;
1116}
1117
1118inline ULONG APIENTRY DosSuspendThread(TID a)
1119{
1120 ULONG yyrc;
1121 USHORT sel = GetFS();
1122
1123 yyrc = DosSuspendThread(a);
1124 SetFS(sel);
1125
1126 return yyrc;
1127}
1128
1129inline ULONG APIENTRY DosVerifyPidTid(PID a, TID b)
1130{
1131 ULONG yyrc;
1132 USHORT sel = GetFS();
1133
1134 yyrc = DosVerifyPidTid(a, b);
1135 SetFS(sel);
1136
1137 return yyrc;
1138}
1139
1140inline ULONG APIENTRY DosWaitChild(ULONG a, ULONG b, PRESULTCODES c, PPID d, PID e)
1141{
1142 ULONG yyrc;
1143 USHORT sel = GetFS();
1144
1145 yyrc = DosWaitChild(a, b, c, d, e);
1146 SetFS(sel);
1147
1148 return yyrc;
1149}
1150
1151inline ULONG APIENTRY DosWaitThread(PTID a, ULONG b)
1152{
1153 ULONG yyrc;
1154 USHORT sel = GetFS();
1155
1156 yyrc = DosWaitThread(a, b);
1157 SetFS(sel);
1158
1159 return yyrc;
1160}
1161
1162#endif
1163#ifdef INCL_DOSSESMGR
1164inline ULONG APIENTRY DosQueryAppType(PCSZ a, PULONG b)
1165{
1166 ULONG yyrc;
1167 USHORT sel = GetFS();
1168
1169 yyrc = DosQueryAppType(a, b);
1170 SetFS(sel);
1171
1172 return yyrc;
1173}
1174
1175inline ULONG APIENTRY DosSelectSession(ULONG a)
1176{
1177 ULONG yyrc;
1178 USHORT sel = GetFS();
1179
1180 yyrc = DosSelectSession(a);
1181 SetFS(sel);
1182
1183 return yyrc;
1184}
1185
1186inline ULONG APIENTRY DosSetSession(ULONG a, PSTATUSDATA b)
1187{
1188 ULONG yyrc;
1189 USHORT sel = GetFS();
1190
1191 yyrc = DosSetSession(a, b);
1192 SetFS(sel);
1193
1194 return yyrc;
1195}
1196
1197inline ULONG APIENTRY DosStartSession(PSTARTDATA a, PULONG b, PPID c)
1198{
1199 ULONG yyrc;
1200 USHORT sel = GetFS();
1201
1202 yyrc = DosStartSession(a, b, c);
1203 SetFS(sel);
1204
1205 return yyrc;
1206}
1207
1208inline ULONG APIENTRY DosStopSession(ULONG a, ULONG b)
1209{
1210 ULONG yyrc;
1211 USHORT sel = GetFS();
1212
1213 yyrc = DosStopSession(a, b);
1214 SetFS(sel);
1215
1216 return yyrc;
1217}
1218
1219#endif
1220#ifdef INCL_DOSSEMAPHORES
1221inline ULONG APIENTRY DosCloseEventSem(HEV a)
1222{
1223 ULONG yyrc;
1224 USHORT sel = GetFS();
1225
1226 yyrc = DosCloseEventSem(a);
1227 SetFS(sel);
1228
1229 return yyrc;
1230}
1231
1232inline ULONG APIENTRY DosCreateEventSem(PCSZ a, PHEV b, ULONG c, BOOL32 d)
1233{
1234 ULONG yyrc;
1235 USHORT sel = GetFS();
1236
1237 yyrc = DosCreateEventSem(a, b, c, d);
1238 SetFS(sel);
1239
1240 return yyrc;
1241}
1242
1243inline ULONG APIENTRY DosOpenEventSem(PCSZ a, PHEV b)
1244{
1245 ULONG yyrc;
1246 USHORT sel = GetFS();
1247
1248 yyrc = DosOpenEventSem(a, b);
1249 SetFS(sel);
1250
1251 return yyrc;
1252}
1253
1254inline ULONG APIENTRY DosPostEventSem(HEV a)
1255{
1256 ULONG yyrc;
1257 USHORT sel = GetFS();
1258
1259 yyrc = DosPostEventSem(a);
1260 SetFS(sel);
1261
1262 return yyrc;
1263}
1264
1265inline ULONG APIENTRY DosQueryEventSem(HEV a, PULONG b)
1266{
1267 ULONG yyrc;
1268 USHORT sel = GetFS();
1269
1270 yyrc = DosQueryEventSem(a, b);
1271 SetFS(sel);
1272
1273 return yyrc;
1274}
1275
1276inline ULONG APIENTRY DosResetEventSem(HEV a, PULONG b)
1277{
1278 ULONG yyrc;
1279 USHORT sel = GetFS();
1280
1281 yyrc = DosResetEventSem(a, b);
1282 SetFS(sel);
1283
1284 return yyrc;
1285}
1286
1287inline ULONG APIENTRY DosWaitEventSem(HEV a, ULONG b)
1288{
1289 ULONG yyrc;
1290 USHORT sel = GetFS();
1291
1292 yyrc = DosWaitEventSem(a, b);
1293 SetFS(sel);
1294
1295 return yyrc;
1296}
1297
1298inline ULONG APIENTRY DosCloseMutexSem(HMTX a)
1299{
1300 ULONG yyrc;
1301 USHORT sel = GetFS();
1302
1303 yyrc = DosCloseMutexSem(a);
1304 SetFS(sel);
1305
1306 return yyrc;
1307}
1308
1309inline ULONG APIENTRY DosCreateMutexSem(PCSZ a, PHMTX b, ULONG c, BOOL32 d)
1310{
1311 ULONG yyrc;
1312 USHORT sel = GetFS();
1313
1314 yyrc = DosCreateMutexSem(a, b, c, d);
1315 SetFS(sel);
1316
1317 return yyrc;
1318}
1319
1320inline ULONG APIENTRY DosOpenMutexSem(PCSZ a, PHMTX b)
1321{
1322 ULONG yyrc;
1323 USHORT sel = GetFS();
1324
1325 yyrc = DosOpenMutexSem(a, b);
1326 SetFS(sel);
1327
1328 return yyrc;
1329}
1330
1331inline ULONG APIENTRY DosQueryMutexSem(HMTX a, PPID b, PTID c, PULONG d)
1332{
1333 ULONG yyrc;
1334 USHORT sel = GetFS();
1335
1336 yyrc = DosQueryMutexSem(a, b, c, d);
1337 SetFS(sel);
1338
1339 return yyrc;
1340}
1341
1342inline ULONG APIENTRY DosReleaseMutexSem(HMTX a)
1343{
1344 ULONG yyrc;
1345 USHORT sel = GetFS();
1346
1347 yyrc = DosReleaseMutexSem(a);
1348 SetFS(sel);
1349
1350 return yyrc;
1351}
1352
1353inline ULONG APIENTRY DosRequestMutexSem(HMTX a, ULONG b)
1354{
1355 ULONG yyrc;
1356 USHORT sel = GetFS();
1357
1358 yyrc = DosRequestMutexSem(a, b);
1359 SetFS(sel);
1360
1361 return yyrc;
1362}
1363
1364inline ULONG APIENTRY DosAddMuxWaitSem(HMUX a, PSEMRECORD b)
1365{
1366 ULONG yyrc;
1367 USHORT sel = GetFS();
1368
1369 yyrc = DosAddMuxWaitSem(a, b);
1370 SetFS(sel);
1371
1372 return yyrc;
1373}
1374
1375inline ULONG APIENTRY DosCloseMuxWaitSem(HMUX a)
1376{
1377 ULONG yyrc;
1378 USHORT sel = GetFS();
1379
1380 yyrc = DosCloseMuxWaitSem(a);
1381 SetFS(sel);
1382
1383 return yyrc;
1384}
1385
1386inline ULONG APIENTRY DosCreateMuxWaitSem(PCSZ a, PHMUX b, ULONG c, PSEMRECORD d, ULONG e)
1387{
1388 ULONG yyrc;
1389 USHORT sel = GetFS();
1390
1391 yyrc = DosCreateMuxWaitSem(a, b, c, d, e);
1392 SetFS(sel);
1393
1394 return yyrc;
1395}
1396
1397inline ULONG APIENTRY DosDeleteMuxWaitSem(HMUX a, HSEM b)
1398{
1399 ULONG yyrc;
1400 USHORT sel = GetFS();
1401
1402 yyrc = DosDeleteMuxWaitSem(a, b);
1403 SetFS(sel);
1404
1405 return yyrc;
1406}
1407
1408inline ULONG APIENTRY DosOpenMuxWaitSem(PCSZ a, PHMUX b)
1409{
1410 ULONG yyrc;
1411 USHORT sel = GetFS();
1412
1413 yyrc = DosOpenMuxWaitSem(a, b);
1414 SetFS(sel);
1415
1416 return yyrc;
1417}
1418
1419inline ULONG APIENTRY DosQueryMuxWaitSem(HMUX a, PULONG b, PSEMRECORD c, PULONG d)
1420{
1421 ULONG yyrc;
1422 USHORT sel = GetFS();
1423
1424 yyrc = DosQueryMuxWaitSem(a, b, c, d);
1425 SetFS(sel);
1426
1427 return yyrc;
1428}
1429
1430inline ULONG APIENTRY DosWaitMuxWaitSem(HMUX a, ULONG b, PULONG c)
1431{
1432 ULONG yyrc;
1433 USHORT sel = GetFS();
1434
1435 yyrc = DosWaitMuxWaitSem(a, b, c);
1436 SetFS(sel);
1437
1438 return yyrc;
1439}
1440
1441#endif
1442#ifdef INCL_DOSNMPIPES
1443inline ULONG APIENTRY DosCallNPipe(PCSZ a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f, ULONG g)
1444{
1445 ULONG yyrc;
1446 USHORT sel = GetFS();
1447
1448 yyrc = DosCallNPipe(a, b, c, d, e, f, g);
1449 SetFS(sel);
1450
1451 return yyrc;
1452}
1453
1454inline ULONG APIENTRY DosConnectNPipe(HPIPE a)
1455{
1456 ULONG yyrc;
1457 USHORT sel = GetFS();
1458
1459 yyrc = DosConnectNPipe(a);
1460 SetFS(sel);
1461
1462 return yyrc;
1463}
1464
1465inline ULONG APIENTRY DosCreateNPipe(PCSZ a, PHPIPE b, ULONG c, ULONG d, ULONG e, ULONG f, ULONG g)
1466{
1467 ULONG yyrc;
1468 USHORT sel = GetFS();
1469
1470 yyrc = DosCreateNPipe(a, b, c, d, e, f, g);
1471 SetFS(sel);
1472
1473 return yyrc;
1474}
1475
1476inline ULONG APIENTRY DosDisConnectNPipe(HPIPE a)
1477{
1478 ULONG yyrc;
1479 USHORT sel = GetFS();
1480
1481 yyrc = DosDisConnectNPipe(a);
1482 SetFS(sel);
1483
1484 return yyrc;
1485}
1486
1487inline ULONG APIENTRY DosPeekNPipe(HPIPE a, PVOID b, ULONG c, PULONG d, PAVAILDATA e, PULONG f)
1488{
1489 ULONG yyrc;
1490 USHORT sel = GetFS();
1491
1492 yyrc = DosPeekNPipe(a, b, c, d, e, f);
1493 SetFS(sel);
1494
1495 return yyrc;
1496}
1497
1498inline ULONG APIENTRY DosQueryNPHState(HPIPE a, PULONG b)
1499{
1500 ULONG yyrc;
1501 USHORT sel = GetFS();
1502
1503 yyrc = DosQueryNPHState(a, b);
1504 SetFS(sel);
1505
1506 return yyrc;
1507}
1508
1509inline ULONG APIENTRY DosQueryNPipeInfo(HPIPE a, ULONG b, PVOID c, ULONG d)
1510{
1511 ULONG yyrc;
1512 USHORT sel = GetFS();
1513
1514 yyrc = DosQueryNPipeInfo(a, b, c, d);
1515 SetFS(sel);
1516
1517 return yyrc;
1518}
1519
1520inline ULONG APIENTRY DosQueryNPipeSemState(HSEM a, PPIPESEMSTATE b, ULONG c)
1521{
1522 ULONG yyrc;
1523 USHORT sel = GetFS();
1524
1525 yyrc = DosQueryNPipeSemState(a, b, c);
1526 SetFS(sel);
1527
1528 return yyrc;
1529}
1530
1531inline ULONG APIENTRY DosRawReadNPipe(PCSZ a, ULONG b, PULONG c, PVOID d)
1532{
1533 ULONG yyrc;
1534 USHORT sel = GetFS();
1535
1536 yyrc = DosRawReadNPipe(a, b, c, d);
1537 SetFS(sel);
1538
1539 return yyrc;
1540}
1541
1542inline ULONG APIENTRY DosRawWriteNPipe(PCSZ a, ULONG b)
1543{
1544 ULONG yyrc;
1545 USHORT sel = GetFS();
1546
1547 yyrc = DosRawWriteNPipe(a, b);
1548 SetFS(sel);
1549
1550 return yyrc;
1551}
1552
1553inline ULONG APIENTRY DosSetNPHState(HPIPE a, ULONG b)
1554{
1555 ULONG yyrc;
1556 USHORT sel = GetFS();
1557
1558 yyrc = DosSetNPHState(a, b);
1559 SetFS(sel);
1560
1561 return yyrc;
1562}
1563
1564inline ULONG APIENTRY DosSetNPipeSem(HPIPE a, HSEM b, ULONG c)
1565{
1566 ULONG yyrc;
1567 USHORT sel = GetFS();
1568
1569 yyrc = DosSetNPipeSem(a, b, c);
1570 SetFS(sel);
1571
1572 return yyrc;
1573}
1574
1575inline ULONG APIENTRY DosTransactNPipe(HPIPE a, PVOID b, ULONG c, PVOID d, ULONG e, PULONG f)
1576{
1577 ULONG yyrc;
1578 USHORT sel = GetFS();
1579
1580 yyrc = DosTransactNPipe(a, b, c, d, e, f);
1581 SetFS(sel);
1582
1583 return yyrc;
1584}
1585
1586inline ULONG APIENTRY DosWaitNPipe(PCSZ a, ULONG b)
1587{
1588 ULONG yyrc;
1589 USHORT sel = GetFS();
1590
1591 yyrc = DosWaitNPipe(a, b);
1592 SetFS(sel);
1593
1594 return yyrc;
1595}
1596
1597inline ULONG APIENTRY DosCreatePipe(PHFILE a, PHFILE b, ULONG c)
1598{
1599 ULONG yyrc;
1600 USHORT sel = GetFS();
1601
1602 yyrc = DosCreatePipe(a, b, c);
1603 SetFS(sel);
1604
1605 return yyrc;
1606}
1607
1608#endif
1609#ifdef INCL_DOSQUEUES
1610inline ULONG APIENTRY DosCloseQueue(HQUEUE a)
1611{
1612 ULONG yyrc;
1613 USHORT sel = GetFS();
1614
1615 yyrc = DosCloseQueue(a);
1616 SetFS(sel);
1617
1618 return yyrc;
1619}
1620
1621inline ULONG APIENTRY DosCreateQueue(PHQUEUE a, ULONG b, PCSZ c)
1622{
1623 ULONG yyrc;
1624 USHORT sel = GetFS();
1625
1626 yyrc = DosCreateQueue(a, b, c);
1627 SetFS(sel);
1628
1629 return yyrc;
1630}
1631
1632inline ULONG APIENTRY DosOpenQueue(PPID a, PHQUEUE b, PCSZ c)
1633{
1634 ULONG yyrc;
1635 USHORT sel = GetFS();
1636
1637 yyrc = DosOpenQueue(a, b, c);
1638 SetFS(sel);
1639
1640 return yyrc;
1641}
1642
1643inline ULONG APIENTRY DosPeekQueue(HQUEUE a, PREQUESTDATA b, PULONG c, PPVOID d, PULONG e, BOOL32 f, PBYTE g, HEV h)
1644{
1645 ULONG yyrc;
1646 USHORT sel = GetFS();
1647
1648 yyrc = DosPeekQueue(a, b, c, d, e, f, g, h);
1649 SetFS(sel);
1650
1651 return yyrc;
1652}
1653
1654inline ULONG APIENTRY DosPurgeQueue(HQUEUE a)
1655{
1656 ULONG yyrc;
1657 USHORT sel = GetFS();
1658
1659 yyrc = DosPurgeQueue(a);
1660 SetFS(sel);
1661
1662 return yyrc;
1663}
1664
1665inline ULONG APIENTRY DosQueryQueue(HQUEUE a, PULONG b)
1666{
1667 ULONG yyrc;
1668 USHORT sel = GetFS();
1669
1670 yyrc = DosQueryQueue(a, b);
1671 SetFS(sel);
1672
1673 return yyrc;
1674}
1675
1676inline ULONG APIENTRY DosReadQueue(HQUEUE a, PREQUESTDATA b, PULONG c, PPVOID d, ULONG e, BOOL32 f, PBYTE g, HEV h)
1677{
1678 ULONG yyrc;
1679 USHORT sel = GetFS();
1680
1681 yyrc = DosReadQueue(a, b, c, d, e, f, g, h);
1682 SetFS(sel);
1683
1684 return yyrc;
1685}
1686
1687inline ULONG APIENTRY DosWriteQueue(HQUEUE a, ULONG b, ULONG c, PVOID d, ULONG e)
1688{
1689 ULONG yyrc;
1690 USHORT sel = GetFS();
1691
1692 yyrc = DosWriteQueue(a, b, c, d, e);
1693 SetFS(sel);
1694
1695 return yyrc;
1696}
1697
1698#endif
1699#ifdef INCL_DOSEXCEPTIONS
1700inline ULONG APIENTRY DosAcknowledgeSignalException(ULONG a)
1701{
1702 ULONG yyrc;
1703 USHORT sel = GetFS();
1704
1705 yyrc = DosAcknowledgeSignalException(a);
1706 SetFS(sel);
1707
1708 return yyrc;
1709}
1710
1711inline ULONG APIENTRY DosEnterMustComplete(PULONG a)
1712{
1713 ULONG yyrc;
1714 USHORT sel = GetFS();
1715
1716 yyrc = DosEnterMustComplete(a);
1717 SetFS(sel);
1718
1719 return yyrc;
1720}
1721
1722inline ULONG APIENTRY DosExitMustComplete(PULONG a)
1723{
1724 ULONG yyrc;
1725 USHORT sel = GetFS();
1726
1727 yyrc = DosExitMustComplete(a);
1728 SetFS(sel);
1729
1730 return yyrc;
1731}
1732
1733inline ULONG APIENTRY DosQueryThreadContext(TID a, ULONG b, PCONTEXTRECORD c)
1734{
1735 ULONG yyrc;
1736 USHORT sel = GetFS();
1737
1738 yyrc = DosQueryThreadContext(a, b, c);
1739 SetFS(sel);
1740
1741 return yyrc;
1742}
1743
1744inline ULONG APIENTRY DosRaiseException(PEXCEPTIONREPORTRECORD a)
1745{
1746 ULONG yyrc;
1747 USHORT sel = GetFS();
1748
1749 yyrc = DosRaiseException(a);
1750 SetFS(sel);
1751
1752 return yyrc;
1753}
1754
1755inline ULONG APIENTRY DosSendSignalException(PID a, ULONG b)
1756{
1757 ULONG yyrc;
1758 USHORT sel = GetFS();
1759
1760 yyrc = DosSendSignalException(a, b);
1761 SetFS(sel);
1762
1763 return yyrc;
1764}
1765
1766inline ULONG APIENTRY DosSetExceptionHandler(PEXCEPTIONREGISTRATIONRECORD a)
1767{
1768 ULONG yyrc;
1769 USHORT sel = GetFS();
1770
1771 yyrc = DosSetExceptionHandler(a);
1772 SetFS(sel);
1773
1774 return yyrc;
1775}
1776
1777inline ULONG APIENTRY DosSetSignalExceptionFocus(BOOL32 a, PULONG b)
1778{
1779 ULONG yyrc;
1780 USHORT sel = GetFS();
1781
1782 yyrc = DosSetSignalExceptionFocus(a, b);
1783 SetFS(sel);
1784
1785 return yyrc;
1786}
1787
1788inline ULONG APIENTRY DosUnsetExceptionHandler(PEXCEPTIONREGISTRATIONRECORD a)
1789{
1790 ULONG yyrc;
1791 USHORT sel = GetFS();
1792
1793 yyrc = DosUnsetExceptionHandler(a);
1794 SetFS(sel);
1795
1796 return yyrc;
1797}
1798
1799inline ULONG APIENTRY DosUnwindException(PEXCEPTIONREGISTRATIONRECORD a, PVOID b, PEXCEPTIONREPORTRECORD c)
1800{
1801 ULONG yyrc;
1802 USHORT sel = GetFS();
1803
1804 yyrc = DosUnwindException(a, b, c);
1805 SetFS(sel);
1806
1807 return yyrc;
1808}
1809
1810#endif
1811#ifdef INCL_DOSMISC
1812inline ULONG APIENTRY DosQuerySysInfo(ULONG a, ULONG b, PVOID c, ULONG d)
1813{
1814 ULONG yyrc;
1815 USHORT sel = GetFS();
1816
1817 yyrc = DosQuerySysInfo(a, b, c, d);
1818 SetFS(sel);
1819
1820 return yyrc;
1821}
1822
1823inline ULONG APIENTRY DosScanEnv(PCSZ a, PSZ *b)
1824{
1825 ULONG yyrc;
1826 USHORT sel = GetFS();
1827
1828 yyrc = DosScanEnv(a, b);
1829 SetFS(sel);
1830
1831 return yyrc;
1832}
1833
1834inline ULONG APIENTRY DosQueryRASInfo(ULONG a, PPVOID b)
1835{
1836 ULONG yyrc;
1837 USHORT sel = GetFS();
1838
1839 yyrc = DosQueryRASInfo(a, b);
1840 SetFS(sel);
1841
1842 return yyrc;
1843}
1844
1845#endif
1846#ifdef INCL_DOSDATETIME
1847inline ULONG APIENTRY DosGetDateTime(PDATETIME a)
1848{
1849 ULONG yyrc;
1850 USHORT sel = GetFS();
1851
1852 yyrc = DosGetDateTime(a);
1853 SetFS(sel);
1854
1855 return yyrc;
1856}
1857
1858inline ULONG APIENTRY DosSetDateTime(CONST DATETIME *a)
1859{
1860 ULONG yyrc;
1861 USHORT sel = GetFS();
1862
1863 yyrc = DosSetDateTime(a);
1864 SetFS(sel);
1865
1866 return yyrc;
1867}
1868
1869inline ULONG APIENTRY DosAsyncTimer(ULONG a, HSEM b, PHTIMER c)
1870{
1871 ULONG yyrc;
1872 USHORT sel = GetFS();
1873
1874 yyrc = DosAsyncTimer(a, b, c);
1875 SetFS(sel);
1876
1877 return yyrc;
1878}
1879
1880inline ULONG APIENTRY DosStartTimer(ULONG a, HSEM b, PHTIMER c)
1881{
1882 ULONG yyrc;
1883 USHORT sel = GetFS();
1884
1885 yyrc = DosStartTimer(a, b, c);
1886 SetFS(sel);
1887
1888 return yyrc;
1889}
1890
1891inline ULONG APIENTRY DosStopTimer(HTIMER a)
1892{
1893 ULONG yyrc;
1894 USHORT sel = GetFS();
1895
1896 yyrc = DosStopTimer(a);
1897 SetFS(sel);
1898
1899 return yyrc;
1900}
1901
1902#endif
1903#ifdef DosTmrQueryFreq
1904inline ULONG APIENTRY DosTmrQueryFreq(PULONG a)
1905{
1906 ULONG yyrc;
1907 USHORT sel = GetFS();
1908
1909 yyrc = DosTmrQueryFreq(a);
1910 SetFS(sel);
1911
1912 return yyrc;
1913}
1914
1915inline ULONG APIENTRY DosTmrQueryTime(PQWORD a)
1916{
1917 ULONG yyrc;
1918 USHORT sel = GetFS();
1919
1920 yyrc = DosTmrQueryTime(a);
1921 SetFS(sel);
1922
1923 return yyrc;
1924}
1925
1926#endif
1927#ifdef INCL_DOSMVDM
1928inline ULONG APIENTRY DosCloseVDD(HVDD a)
1929{
1930 ULONG yyrc;
1931 USHORT sel = GetFS();
1932
1933 yyrc = DosCloseVDD(a);
1934 SetFS(sel);
1935
1936 return yyrc;
1937}
1938
1939inline ULONG APIENTRY DosOpenVDD(PCSZ a, PHVDD b)
1940{
1941 ULONG yyrc;
1942 USHORT sel = GetFS();
1943
1944 yyrc = DosOpenVDD(a, b);
1945 SetFS(sel);
1946
1947 return yyrc;
1948}
1949
1950inline ULONG APIENTRY DosQueryDOSProperty(SGID a, PCSZ b, ULONG c, PSZ d)
1951{
1952 ULONG yyrc;
1953 USHORT sel = GetFS();
1954
1955 yyrc = DosQueryDOSProperty(a, b, c, d);
1956 SetFS(sel);
1957
1958 return yyrc;
1959}
1960
1961inline ULONG APIENTRY DosRequestVDD(HVDD a, SGID b, ULONG c, ULONG d, PVOID e, ULONG f, PVOID g)
1962{
1963 ULONG yyrc;
1964 USHORT sel = GetFS();
1965
1966 yyrc = DosRequestVDD(a, b, c, d, e, f, g);
1967 SetFS(sel);
1968
1969 return yyrc;
1970}
1971
1972inline ULONG APIENTRY DosSetDOSProperty(SGID a, PCSZ b, ULONG c, PCSZ d)
1973{
1974 ULONG yyrc;
1975 USHORT sel = GetFS();
1976
1977 yyrc = DosSetDOSProperty(a, b, c, d);
1978 SetFS(sel);
1979
1980 return yyrc;
1981}
1982
1983#endif
1984#ifdef INCL_DOSPROCESS
1985inline ULONG APIENTRY DosDebug(uDB_t *a)
1986{
1987 ULONG yyrc;
1988 USHORT sel = GetFS();
1989
1990 yyrc = DosDebug(a);
1991 SetFS(sel);
1992
1993 return yyrc;
1994}
1995
1996#endif
1997#ifdef INCL_DOSMISC
1998inline ULONG APIENTRY DosGetMessage(PCHAR *a, ULONG b, PCHAR c, ULONG d, ULONG e, PCSZ f, PULONG g)
1999{
2000 ULONG yyrc;
2001 USHORT sel = GetFS();
2002
2003 yyrc = DosGetMessage(a, b, c, d, e, f, g);
2004 SetFS(sel);
2005
2006 return yyrc;
2007}
2008
2009inline ULONG APIENTRY DosInsertMessage(PCHAR *a, ULONG b, PCSZ c, ULONG d, PCHAR e, ULONG f, PULONG g)
2010{
2011 ULONG yyrc;
2012 USHORT sel = GetFS();
2013
2014 yyrc = DosInsertMessage(a, b, c, d, e, f, g);
2015 SetFS(sel);
2016
2017 return yyrc;
2018}
2019
2020inline ULONG APIENTRY DosPutMessage(HFILE a, ULONG b, PCHAR c)
2021{
2022 ULONG yyrc;
2023 USHORT sel = GetFS();
2024
2025 yyrc = DosPutMessage(a, b, c);
2026 SetFS(sel);
2027
2028 return yyrc;
2029}
2030
2031inline ULONG APIENTRY DosQueryMessageCP(PCHAR a, ULONG b, PCSZ c, PULONG d)
2032{
2033 ULONG yyrc;
2034 USHORT sel = GetFS();
2035
2036 yyrc = DosQueryMessageCP(a, b, c, d);
2037 SetFS(sel);
2038
2039 return yyrc;
2040}
2041
2042#endif
2043#ifdef INCL_DOSRAS
2044inline ULONG APIENTRY DosDumpProcess(ULONG a, ULONG b, PID c)
2045{
2046 ULONG yyrc;
2047 USHORT sel = GetFS();
2048
2049 yyrc = DosDumpProcess(a, b, c);
2050 SetFS(sel);
2051
2052 return yyrc;
2053}
2054
2055inline ULONG APIENTRY DosForceSystemDump(ULONG a)
2056{
2057 ULONG yyrc;
2058 USHORT sel = GetFS();
2059
2060 yyrc = DosForceSystemDump(a);
2061 SetFS(sel);
2062
2063 return yyrc;
2064}
2065
2066inline ULONG APIENTRY DosQueryRASInfo(ULONG a, PPVOID b)
2067{
2068 ULONG yyrc;
2069 USHORT sel = GetFS();
2070
2071 yyrc = DosQueryRASInfo(a, b);
2072 SetFS(sel);
2073
2074 return yyrc;
2075}
2076
2077inline ULONG APIENTRY DosSuppressPopUps(ULONG a, ULONG b)
2078{
2079 ULONG yyrc;
2080 USHORT sel = GetFS();
2081
2082 yyrc = DosSuppressPopUps(a, b);
2083 SetFS(sel);
2084
2085 return yyrc;
2086}
2087
2088#endif
2089#ifdef INCL_RXSUBCOM
2090inline ULONG APIENTRY RexxDeregisterSubcom(PCSZ a, PCSZ b)
2091{
2092 ULONG yyrc;
2093 USHORT sel = GetFS();
2094
2095 yyrc = RexxDeregisterSubcom(a, b);
2096 SetFS(sel);
2097
2098 return yyrc;
2099}
2100
2101inline ULONG APIENTRY RexxQuerySubcom(PCSZ a, PCSZ b, PUSHORT c, PUCHAR d)
2102{
2103 ULONG yyrc;
2104 USHORT sel = GetFS();
2105
2106 yyrc = RexxQuerySubcom(a, b, c, d);
2107 SetFS(sel);
2108
2109 return yyrc;
2110}
2111
2112inline ULONG APIENTRY RexxRegisterSubcomDll(PCSZ a, PCSZ b, PCSZ c, PUCHAR d, ULONG e)
2113{
2114 ULONG yyrc;
2115 USHORT sel = GetFS();
2116
2117 yyrc = RexxRegisterSubcomDll(a, b, c, d, e);
2118 SetFS(sel);
2119
2120 return yyrc;
2121}
2122
2123inline ULONG APIENTRY RexxRegisterSubcomExe(PCSZ a, PFN b, PUCHAR c)
2124{
2125 ULONG yyrc;
2126 USHORT sel = GetFS();
2127
2128 yyrc = RexxRegisterSubcomExe(a, b, c);
2129 SetFS(sel);
2130
2131 return yyrc;
2132}
2133
2134#endif
2135#ifdef INCL_RXSHV
2136inline ULONG APIENTRY RexxVariablePool(PSHVBLOCK a)
2137{
2138 ULONG yyrc;
2139 USHORT sel = GetFS();
2140
2141 yyrc = RexxVariablePool(a);
2142 SetFS(sel);
2143
2144 return yyrc;
2145}
2146
2147#endif
2148#ifdef INCL_RXFUNC
2149inline ULONG APIENTRY RexxDeregisterFunction(PCSZ a)
2150{
2151 ULONG yyrc;
2152 USHORT sel = GetFS();
2153
2154 yyrc = RexxDeregisterFunction(a);
2155 SetFS(sel);
2156
2157 return yyrc;
2158}
2159
2160inline ULONG APIENTRY RexxQueryFunction(PCSZ a)
2161{
2162 ULONG yyrc;
2163 USHORT sel = GetFS();
2164
2165 yyrc = RexxQueryFunction(a);
2166 SetFS(sel);
2167
2168 return yyrc;
2169}
2170
2171inline ULONG APIENTRY RexxRegisterFunctionDll(PCSZ a, PCSZ b, PCSZ c)
2172{
2173 ULONG yyrc;
2174 USHORT sel = GetFS();
2175
2176 yyrc = RexxRegisterFunctionDll(a, b, c);
2177 SetFS(sel);
2178
2179 return yyrc;
2180}
2181
2182inline ULONG APIENTRY RexxRegisterFunctionExe(PCSZ a, RexxFunctionHandler *b)
2183{
2184 ULONG yyrc;
2185 USHORT sel = GetFS();
2186
2187 yyrc = RexxRegisterFunctionExe(a, b);
2188 SetFS(sel);
2189
2190 return yyrc;
2191}
2192
2193#endif
2194#ifdef INCL_RXSYSEXIT
2195inline ULONG APIENTRY RexxDeregisterExit(PCSZ a, PCSZ b)
2196{
2197 ULONG yyrc;
2198 USHORT sel = GetFS();
2199
2200 yyrc = RexxDeregisterExit(a, b);
2201 SetFS(sel);
2202
2203 return yyrc;
2204}
2205
2206inline ULONG APIENTRY RexxQueryExit(PCSZ a, PCSZ b, PUSHORT c, PUCHAR d)
2207{
2208 ULONG yyrc;
2209 USHORT sel = GetFS();
2210
2211 yyrc = RexxQueryExit(a, b, c, d);
2212 SetFS(sel);
2213
2214 return yyrc;
2215}
2216
2217inline ULONG APIENTRY RexxRegisterExitDll(PCSZ a, PCSZ b, PCSZ c, PUCHAR d, ULONG e)
2218{
2219 ULONG yyrc;
2220 USHORT sel = GetFS();
2221
2222 yyrc = RexxRegisterExitDll(a, b, c, d, e);
2223 SetFS(sel);
2224
2225 return yyrc;
2226}
2227
2228inline ULONG APIENTRY RexxRegisterExitExe(PCSZ a, PFN b, PUCHAR c)
2229{
2230 ULONG yyrc;
2231 USHORT sel = GetFS();
2232
2233 yyrc = RexxRegisterExitExe(a, b, c);
2234 SetFS(sel);
2235
2236 return yyrc;
2237}
2238
2239#endif
2240#ifdef INCL_RXARI
2241inline ULONG APIENTRY RexxResetTrace(PID a, TID b)
2242{
2243 ULONG yyrc;
2244 USHORT sel = GetFS();
2245
2246 yyrc = RexxResetTrace(a, b);
2247 SetFS(sel);
2248
2249 return yyrc;
2250}
2251
2252inline ULONG APIENTRY RexxSetHalt(PID a, TID b)
2253{
2254 ULONG yyrc;
2255 USHORT sel = GetFS();
2256
2257 yyrc = RexxSetHalt(a, b);
2258 SetFS(sel);
2259
2260 return yyrc;
2261}
2262
2263inline ULONG APIENTRY RexxSetTrace(PID a, TID b)
2264{
2265 ULONG yyrc;
2266 USHORT sel = GetFS();
2267
2268 yyrc = RexxSetTrace(a, b);
2269 SetFS(sel);
2270
2271 return yyrc;
2272}
2273
2274#endif
2275#ifdef INCL_RXMACRO
2276inline ULONG APIENTRY RexxAddMacro(PCSZ a, PCSZ b, ULONG c)
2277{
2278 ULONG yyrc;
2279 USHORT sel = GetFS();
2280
2281 yyrc = RexxAddMacro(a, b, c);
2282 SetFS(sel);
2283
2284 return yyrc;
2285}
2286
2287inline ULONG APIENTRY RexxClearMacroSpace()
2288{
2289 ULONG yyrc;
2290 USHORT sel = GetFS();
2291
2292 yyrc = RexxClearMacroSpace();
2293 SetFS(sel);
2294
2295 return yyrc;
2296}
2297
2298inline ULONG APIENTRY RexxDropMacro(PCSZ a)
2299{
2300 ULONG yyrc;
2301 USHORT sel = GetFS();
2302
2303 yyrc = RexxDropMacro(a);
2304 SetFS(sel);
2305
2306 return yyrc;
2307}
2308
2309inline ULONG APIENTRY RexxLoadMacroSpace(ULONG a, PCSZ *b, PCSZ c)
2310{
2311 ULONG yyrc;
2312 USHORT sel = GetFS();
2313
2314 yyrc = RexxLoadMacroSpace(a, b, c);
2315 SetFS(sel);
2316
2317 return yyrc;
2318}
2319
2320inline ULONG APIENTRY RexxQueryMacro(PCSZ a, PUSHORT b)
2321{
2322 ULONG yyrc;
2323 USHORT sel = GetFS();
2324
2325 yyrc = RexxQueryMacro(a, b);
2326 SetFS(sel);
2327
2328 return yyrc;
2329}
2330
2331inline ULONG APIENTRY RexxReorderMacro(PCSZ a, ULONG b)
2332{
2333 ULONG yyrc;
2334 USHORT sel = GetFS();
2335
2336 yyrc = RexxReorderMacro(a, b);
2337 SetFS(sel);
2338
2339 return yyrc;
2340}
2341
2342inline ULONG APIENTRY RexxSaveMacroSpace(ULONG a, PCSZ *b, PCSZ c)
2343{
2344 ULONG yyrc;
2345 USHORT sel = GetFS();
2346
2347 yyrc = RexxSaveMacroSpace(a, b, c);
2348 SetFS(sel);
2349
2350 return yyrc;
2351}
2352
2353inline LONG APIENTRY RexxStart(LONG a, PRXSTRING b, PCSZ c, PRXSTRING d, PCSZ e, LONG f, PRXSYSEXIT g, PSHORT h, PRXSTRING i)
2354{
2355 LONG yyrc;
2356 USHORT sel = GetFS();
2357
2358 yyrc = RexxStart(a, b, c, d, e, f, g, h, i);
2359 SetFS(sel);
2360
2361 return yyrc;
2362}
2363
2364#endif
2365#ifdef INCL_WIN
2366#ifdef INCL_WINMESSAGEMGR
2367inline BOOL APIENTRY WinCancelShutdown(HMQ a, BOOL b)
2368{
2369 BOOL yyrc;
2370 USHORT sel = GetFS();
2371
2372 yyrc = WinCancelShutdown(a, b);
2373 SetFS(sel);
2374
2375 return yyrc;
2376}
2377
2378inline HMQ APIENTRY WinCreateMsgQueue(HAB a, LONG b)
2379{
2380 HMQ yyrc;
2381 USHORT sel = GetFS();
2382
2383 yyrc = WinCreateMsgQueue(a, b);
2384 SetFS(sel);
2385
2386 return yyrc;
2387}
2388
2389inline BOOL APIENTRY WinDestroyMsgQueue(HMQ a)
2390{
2391 BOOL yyrc;
2392 USHORT sel = GetFS();
2393
2394 yyrc = WinDestroyMsgQueue(a);
2395 SetFS(sel);
2396
2397 return yyrc;
2398}
2399
2400inline MRESULT APIENTRY WinDispatchMsg(HAB a, PQMSG b)
2401{
2402 MRESULT yyrc;
2403 USHORT sel = GetFS();
2404
2405 yyrc = WinDispatchMsg(a, b);
2406 SetFS(sel);
2407
2408 return yyrc;
2409}
2410
2411inline BOOL APIENTRY WinGetMsg(HAB a, PQMSG b, HWND c, ULONG d, ULONG e)
2412{
2413 BOOL yyrc;
2414 USHORT sel = GetFS();
2415
2416 yyrc = WinGetMsg(a, b, c, d, e);
2417 SetFS(sel);
2418
2419 return yyrc;
2420}
2421
2422inline BOOL APIENTRY WinLockInput(HMQ a, ULONG b)
2423{
2424 BOOL yyrc;
2425 USHORT sel = GetFS();
2426
2427 yyrc = WinLockInput(a, b);
2428 SetFS(sel);
2429
2430 return yyrc;
2431}
2432
2433inline BOOL APIENTRY WinPeekMsg(HAB a, PQMSG b, HWND c, ULONG d, ULONG e, ULONG f)
2434{
2435 BOOL yyrc;
2436 USHORT sel = GetFS();
2437
2438 yyrc = WinPeekMsg(a, b, c, d, e, f);
2439 SetFS(sel);
2440
2441 return yyrc;
2442}
2443
2444inline BOOL APIENTRY WinPostMsg(HWND a, ULONG b, MPARAM c, MPARAM d)
2445{
2446 BOOL yyrc;
2447 USHORT sel = GetFS();
2448
2449 yyrc = WinPostMsg(a, b, c, d);
2450 SetFS(sel);
2451
2452 return yyrc;
2453}
2454
2455inline HMQ APIENTRY WinQueueFromID(HAB a, PID b, TID c)
2456{
2457 HMQ yyrc;
2458 USHORT sel = GetFS();
2459
2460 yyrc = WinQueueFromID(a, b, c);
2461 SetFS(sel);
2462
2463 return yyrc;
2464}
2465
2466inline BOOL APIENTRY WinQueryQueueInfo(HMQ a, PMQINFO b, ULONG c)
2467{
2468 BOOL yyrc;
2469 USHORT sel = GetFS();
2470
2471 yyrc = WinQueryQueueInfo(a, b, c);
2472 SetFS(sel);
2473
2474 return yyrc;
2475}
2476
2477inline HMQ APIENTRY WinQuerySendMsg(HAB a, HMQ b, HMQ c, PQMSG d)
2478{
2479 HMQ yyrc;
2480 USHORT sel = GetFS();
2481
2482 yyrc = WinQuerySendMsg(a, b, c, d);
2483 SetFS(sel);
2484
2485 return yyrc;
2486}
2487
2488inline BOOL APIENTRY WinRegisterUserDatatype(HAB a, LONG b, LONG c, PLONG d)
2489{
2490 BOOL yyrc;
2491 USHORT sel = GetFS();
2492
2493 yyrc = WinRegisterUserDatatype(a, b, c, d);
2494 SetFS(sel);
2495
2496 return yyrc;
2497}
2498
2499inline BOOL APIENTRY WinRegisterUserMsg(HAB a, ULONG b, LONG c, LONG d, LONG e, LONG f, LONG g)
2500{
2501 BOOL yyrc;
2502 USHORT sel = GetFS();
2503
2504 yyrc = WinRegisterUserMsg(a, b, c, d, e, f, g);
2505 SetFS(sel);
2506
2507 return yyrc;
2508}
2509
2510inline BOOL APIENTRY WinReplyMsg(HAB a, HMQ b, HMQ c, MRESULT d)
2511{
2512 BOOL yyrc;
2513 USHORT sel = GetFS();
2514
2515 yyrc = WinReplyMsg(a, b, c, d);
2516 SetFS(sel);
2517
2518 return yyrc;
2519}
2520
2521inline MRESULT APIENTRY WinSendMsg(HWND a, ULONG b, MPARAM c, MPARAM d)
2522{
2523 MRESULT yyrc;
2524 USHORT sel = GetFS();
2525
2526 yyrc = WinSendMsg(a, b, c, d);
2527 SetFS(sel);
2528
2529 return yyrc;
2530}
2531
2532inline BOOL APIENTRY WinSetMsgMode(HAB a, PCSZ b, LONG c)
2533{
2534 BOOL yyrc;
2535 USHORT sel = GetFS();
2536
2537 yyrc = WinSetMsgMode(a, b, c);
2538 SetFS(sel);
2539
2540 return yyrc;
2541}
2542
2543inline BOOL APIENTRY WinSetSynchroMode(HAB a, LONG b)
2544{
2545 BOOL yyrc;
2546 USHORT sel = GetFS();
2547
2548 yyrc = WinSetSynchroMode(a, b);
2549 SetFS(sel);
2550
2551 return yyrc;
2552}
2553
2554inline BOOL APIENTRY WinThreadAssocQueue(HAB a, HMQ b)
2555{
2556 BOOL yyrc;
2557 USHORT sel = GetFS();
2558
2559 yyrc = WinThreadAssocQueue(a, b);
2560 SetFS(sel);
2561
2562 return yyrc;
2563}
2564
2565inline BOOL APIENTRY WinWakeThread(HMQ a)
2566{
2567 BOOL yyrc;
2568 USHORT sel = GetFS();
2569
2570 yyrc = WinWakeThread(a);
2571 SetFS(sel);
2572
2573 return yyrc;
2574}
2575
2576#endif
2577inline HWND APIENTRY WinCreateWindow(HWND a, PCSZ b, PCSZ c, ULONG d, LONG e, LONG f, LONG g, LONG h, HWND i, HWND j, ULONG k, PVOID l, PVOID m)
2578{
2579 HWND yyrc;
2580 USHORT sel = GetFS();
2581
2582 yyrc = WinCreateWindow(a, b, c, d, e, f, g, h, i, j, k, l, m);
2583 SetFS(sel);
2584
2585 return yyrc;
2586}
2587
2588inline BOOL APIENTRY WinDrawBitmap(HPS a, HBITMAP b, CONST RECTL *c, CONST POINTL *d, LONG e, LONG f, ULONG g)
2589{
2590 BOOL yyrc;
2591 USHORT sel = GetFS();
2592
2593 yyrc = WinDrawBitmap(a, b, c, d, e, f, g);
2594 SetFS(sel);
2595
2596 return yyrc;
2597}
2598
2599inline BOOL APIENTRY WinDrawBorder(HPS a, CONST RECTL *b, LONG c, LONG d, LONG e, LONG f, ULONG g)
2600{
2601 BOOL yyrc;
2602 USHORT sel = GetFS();
2603
2604 yyrc = WinDrawBorder(a, b, c, d, e, f, g);
2605 SetFS(sel);
2606
2607 return yyrc;
2608}
2609
2610inline LONG APIENTRY WinDrawText(HPS a, LONG b, PCH c, PRECTL d, LONG e, LONG f, ULONG g)
2611{
2612 LONG yyrc;
2613 USHORT sel = GetFS();
2614
2615 yyrc = WinDrawText(a, b, c, d, e, f, g);
2616 SetFS(sel);
2617
2618 return yyrc;
2619}
2620
2621inline BOOL APIENTRY WinEnableWindow(HWND a, BOOL b)
2622{
2623 BOOL yyrc;
2624 USHORT sel = GetFS();
2625
2626 yyrc = WinEnableWindow(a, b);
2627 SetFS(sel);
2628
2629 return yyrc;
2630}
2631
2632inline BOOL APIENTRY WinEnableWindowUpdate(HWND a, BOOL b)
2633{
2634 BOOL yyrc;
2635 USHORT sel = GetFS();
2636
2637 yyrc = WinEnableWindowUpdate(a, b);
2638 SetFS(sel);
2639
2640 return yyrc;
2641}
2642
2643inline BOOL APIENTRY WinInvalidateRect(HWND a, CONST RECTL *b, BOOL c)
2644{
2645 BOOL yyrc;
2646 USHORT sel = GetFS();
2647
2648 yyrc = WinInvalidateRect(a, b, c);
2649 SetFS(sel);
2650
2651 return yyrc;
2652}
2653
2654inline BOOL APIENTRY WinInvalidateRegion(HWND a, HRGN b, BOOL c)
2655{
2656 BOOL yyrc;
2657 USHORT sel = GetFS();
2658
2659 yyrc = WinInvalidateRegion(a, b, c);
2660 SetFS(sel);
2661
2662 return yyrc;
2663}
2664
2665inline BOOL APIENTRY WinInvertRect(HPS a, CONST RECTL *b)
2666{
2667 BOOL yyrc;
2668 USHORT sel = GetFS();
2669
2670 yyrc = WinInvertRect(a, b);
2671 SetFS(sel);
2672
2673 return yyrc;
2674}
2675
2676inline BOOL APIENTRY WinIsChild(HWND a, HWND b)
2677{
2678 BOOL yyrc;
2679 USHORT sel = GetFS();
2680
2681 yyrc = WinIsChild(a, b);
2682 SetFS(sel);
2683
2684 return yyrc;
2685}
2686
2687inline BOOL APIENTRY WinIsWindow(HAB a, HWND b)
2688{
2689 BOOL yyrc;
2690 USHORT sel = GetFS();
2691
2692 yyrc = WinIsWindow(a, b);
2693 SetFS(sel);
2694
2695 return yyrc;
2696}
2697
2698inline BOOL APIENTRY WinIsWindowEnabled(HWND a)
2699{
2700 BOOL yyrc;
2701 USHORT sel = GetFS();
2702
2703 yyrc = WinIsWindowEnabled(a);
2704 SetFS(sel);
2705
2706 return yyrc;
2707}
2708
2709inline BOOL APIENTRY WinIsWindowVisible(HWND a)
2710{
2711 BOOL yyrc;
2712 USHORT sel = GetFS();
2713
2714 yyrc = WinIsWindowVisible(a);
2715 SetFS(sel);
2716
2717 return yyrc;
2718}
2719
2720inline LONG APIENTRY WinLoadMessage(HAB a, HMODULE b, ULONG c, LONG d, PSZ e)
2721{
2722 LONG yyrc;
2723 USHORT sel = GetFS();
2724
2725 yyrc = WinLoadMessage(a, b, c, d, e);
2726 SetFS(sel);
2727
2728 return yyrc;
2729}
2730
2731inline LONG APIENTRY WinLoadString(HAB a, HMODULE b, ULONG c, LONG d, PSZ e)
2732{
2733 LONG yyrc;
2734 USHORT sel = GetFS();
2735
2736 yyrc = WinLoadString(a, b, c, d, e);
2737 SetFS(sel);
2738
2739 return yyrc;
2740}
2741
2742inline LONG APIENTRY WinMultWindowFromIDs(HWND a, PHWND b, ULONG c, ULONG d)
2743{
2744 LONG yyrc;
2745 USHORT sel = GetFS();
2746
2747 yyrc = WinMultWindowFromIDs(a, b, c, d);
2748 SetFS(sel);
2749
2750 return yyrc;
2751}
2752
2753inline HWND APIENTRY WinQueryDesktopWindow(HAB a, HDC b)
2754{
2755 HWND yyrc;
2756 USHORT sel = GetFS();
2757
2758 yyrc = WinQueryDesktopWindow(a, b);
2759 SetFS(sel);
2760
2761 return yyrc;
2762}
2763
2764inline HWND APIENTRY WinQueryObjectWindow(HWND a)
2765{
2766 HWND yyrc;
2767 USHORT sel = GetFS();
2768
2769 yyrc = WinQueryObjectWindow(a);
2770 SetFS(sel);
2771
2772 return yyrc;
2773}
2774
2775inline HPOINTER APIENTRY WinQueryPointer(HWND a)
2776{
2777 HPOINTER yyrc;
2778 USHORT sel = GetFS();
2779
2780 yyrc = WinQueryPointer(a);
2781 SetFS(sel);
2782
2783 return yyrc;
2784}
2785
2786inline HWND APIENTRY WinQueryWindow(HWND a, LONG b)
2787{
2788 HWND yyrc;
2789 USHORT sel = GetFS();
2790
2791 yyrc = WinQueryWindow(a, b);
2792 SetFS(sel);
2793
2794 return yyrc;
2795}
2796
2797inline BOOL APIENTRY WinQueryWindowPos(HWND a, PSWP b)
2798{
2799 BOOL yyrc;
2800 USHORT sel = GetFS();
2801
2802 yyrc = WinQueryWindowPos(a, b);
2803 SetFS(sel);
2804
2805 return yyrc;
2806}
2807
2808inline BOOL APIENTRY WinQueryWindowProcess(HWND a, PPID b, PTID c)
2809{
2810 BOOL yyrc;
2811 USHORT sel = GetFS();
2812
2813 yyrc = WinQueryWindowProcess(a, b, c);
2814 SetFS(sel);
2815
2816 return yyrc;
2817}
2818
2819inline LONG APIENTRY WinQueryWindowText(HWND a, LONG b, PCH c)
2820{
2821 LONG yyrc;
2822 USHORT sel = GetFS();
2823
2824 yyrc = WinQueryWindowText(a, b, c);
2825 SetFS(sel);
2826
2827 return yyrc;
2828}
2829
2830inline LONG APIENTRY WinQueryWindowTextLength(HWND a)
2831{
2832 LONG yyrc;
2833 USHORT sel = GetFS();
2834
2835 yyrc = WinQueryWindowTextLength(a);
2836 SetFS(sel);
2837
2838 return yyrc;
2839}
2840
2841inline BOOL APIENTRY WinSetMultWindowPos(HAB a, CONST SWP *b, ULONG c)
2842{
2843 BOOL yyrc;
2844 USHORT sel = GetFS();
2845
2846 yyrc = WinSetMultWindowPos(a, b, c);
2847 SetFS(sel);
2848
2849 return yyrc;
2850}
2851
2852inline BOOL APIENTRY WinSetOwner(HWND a, HWND b)
2853{
2854 BOOL yyrc;
2855 USHORT sel = GetFS();
2856
2857 yyrc = WinSetOwner(a, b);
2858 SetFS(sel);
2859
2860 return yyrc;
2861}
2862
2863inline BOOL APIENTRY WinSetParent(HWND a, HWND b, BOOL c)
2864{
2865 BOOL yyrc;
2866 USHORT sel = GetFS();
2867
2868 yyrc = WinSetParent(a, b, c);
2869 SetFS(sel);
2870
2871 return yyrc;
2872}
2873
2874inline BOOL APIENTRY WinSetWindowPos(HWND a, HWND b, LONG c, LONG d, LONG e, LONG f, ULONG g)
2875{
2876 BOOL yyrc;
2877 USHORT sel = GetFS();
2878
2879 yyrc = WinSetWindowPos(a, b, c, d, e, f, g);
2880 SetFS(sel);
2881
2882 return yyrc;
2883}
2884
2885inline BOOL APIENTRY WinSetWindowText(HWND a, PCSZ b)
2886{
2887 BOOL yyrc;
2888 USHORT sel = GetFS();
2889
2890 yyrc = WinSetWindowText(a, b);
2891 SetFS(sel);
2892
2893 return yyrc;
2894}
2895
2896inline BOOL APIENTRY WinUpdateWindow(HWND a)
2897{
2898 BOOL yyrc;
2899 USHORT sel = GetFS();
2900
2901 yyrc = WinUpdateWindow(a);
2902 SetFS(sel);
2903
2904 return yyrc;
2905}
2906
2907inline HWND APIENTRY WinWindowFromID(HWND a, ULONG b)
2908{
2909 HWND yyrc;
2910 USHORT sel = GetFS();
2911
2912 yyrc = WinWindowFromID(a, b);
2913 SetFS(sel);
2914
2915 return yyrc;
2916}
2917
2918#ifdef INCL_WINFRAMEMGR
2919inline HWND APIENTRY WinCreateStdWindow(HWND a, ULONG b, PULONG c, PCSZ d, PCSZ e, ULONG f, HMODULE g, ULONG h, PHWND i)
2920{
2921 HWND yyrc;
2922 USHORT sel = GetFS();
2923
2924 yyrc = WinCreateStdWindow(a, b, c, d, e, f, g, h, i);
2925 SetFS(sel);
2926
2927 return yyrc;
2928}
2929
2930inline BOOL APIENTRY WinCalcFrameRect(HWND a, PRECTL b, BOOL c)
2931{
2932 BOOL yyrc;
2933 USHORT sel = GetFS();
2934
2935 yyrc = WinCalcFrameRect(a, b, c);
2936 SetFS(sel);
2937
2938 return yyrc;
2939}
2940
2941inline BOOL APIENTRY WinCreateFrameControls(HWND a, PFRAMECDATA b, PCSZ c)
2942{
2943 BOOL yyrc;
2944 USHORT sel = GetFS();
2945
2946 yyrc = WinCreateFrameControls(a, b, c);
2947 SetFS(sel);
2948
2949 return yyrc;
2950}
2951
2952inline BOOL APIENTRY WinFlashWindow(HWND a, BOOL b)
2953{
2954 BOOL yyrc;
2955 USHORT sel = GetFS();
2956
2957 yyrc = WinFlashWindow(a, b);
2958 SetFS(sel);
2959
2960 return yyrc;
2961}
2962
2963inline BOOL APIENTRY WinGetMaxPosition(HWND a, PSWP b)
2964{
2965 BOOL yyrc;
2966 USHORT sel = GetFS();
2967
2968 yyrc = WinGetMaxPosition(a, b);
2969 SetFS(sel);
2970
2971 return yyrc;
2972}
2973
2974inline BOOL APIENTRY WinGetMinPosition(HWND a, PSWP b, CONST POINTL *c)
2975{
2976 BOOL yyrc;
2977 USHORT sel = GetFS();
2978
2979 yyrc = WinGetMinPosition(a, b, c);
2980 SetFS(sel);
2981
2982 return yyrc;
2983}
2984
2985inline BOOL APIENTRY WinSaveWindowPos(HSAVEWP a, PSWP b, ULONG c)
2986{
2987 BOOL yyrc;
2988 USHORT sel = GetFS();
2989
2990 yyrc = WinSaveWindowPos(a, b, c);
2991 SetFS(sel);
2992
2993 return yyrc;
2994}
2995
2996#endif
2997#ifdef INCL_WINWINDOWMGR
2998inline HPS APIENTRY WinBeginPaint(HWND a, HPS b, PRECTL c)
2999{
3000 HPS yyrc;
3001 USHORT sel = GetFS();
3002
3003 yyrc = WinBeginPaint(a, b, c);
3004 SetFS(sel);
3005
3006 return yyrc;
3007}
3008
3009inline MRESULT APIENTRY WinDefWindowProc(HWND a, ULONG b, MPARAM c, MPARAM d)
3010{
3011 MRESULT yyrc;
3012 USHORT sel = GetFS();
3013
3014 yyrc = WinDefWindowProc(a, b, c, d);
3015 SetFS(sel);
3016
3017 return yyrc;
3018}
3019
3020inline BOOL APIENTRY WinDestroyWindow(HWND a)
3021{
3022 BOOL yyrc;
3023 USHORT sel = GetFS();
3024
3025 yyrc = WinDestroyWindow(a);
3026 SetFS(sel);
3027
3028 return yyrc;
3029}
3030
3031inline BOOL APIENTRY WinEndPaint(HPS a)
3032{
3033 BOOL yyrc;
3034 USHORT sel = GetFS();
3035
3036 yyrc = WinEndPaint(a);
3037 SetFS(sel);
3038
3039 return yyrc;
3040}
3041
3042inline BOOL APIENTRY WinFillRect(HPS a, CONST RECTL *b, LONG c)
3043{
3044 BOOL yyrc;
3045 USHORT sel = GetFS();
3046
3047 yyrc = WinFillRect(a, b, c);
3048 SetFS(sel);
3049
3050 return yyrc;
3051}
3052
3053inline HPS APIENTRY WinGetClipPS(HWND a, HWND b, ULONG c)
3054{
3055 HPS yyrc;
3056 USHORT sel = GetFS();
3057
3058 yyrc = WinGetClipPS(a, b, c);
3059 SetFS(sel);
3060
3061 return yyrc;
3062}
3063
3064inline HPS APIENTRY WinGetPS(HWND a)
3065{
3066 HPS yyrc;
3067 USHORT sel = GetFS();
3068
3069 yyrc = WinGetPS(a);
3070 SetFS(sel);
3071
3072 return yyrc;
3073}
3074
3075inline HAB APIENTRY WinInitialize(ULONG a)
3076{
3077 HAB yyrc;
3078 USHORT sel = GetFS();
3079
3080 yyrc = WinInitialize(a);
3081 SetFS(sel);
3082
3083 return yyrc;
3084}
3085
3086inline BOOL APIENTRY WinIsWindowShowing(HWND a)
3087{
3088 BOOL yyrc;
3089 USHORT sel = GetFS();
3090
3091 yyrc = WinIsWindowShowing(a);
3092 SetFS(sel);
3093
3094 return yyrc;
3095}
3096
3097inline HDC APIENTRY WinOpenWindowDC(HWND a)
3098{
3099 HDC yyrc;
3100 USHORT sel = GetFS();
3101
3102 yyrc = WinOpenWindowDC(a);
3103 SetFS(sel);
3104
3105 return yyrc;
3106}
3107
3108inline HAB APIENTRY WinQueryAnchorBlock(HWND a)
3109{
3110 HAB yyrc;
3111 USHORT sel = GetFS();
3112
3113 yyrc = WinQueryAnchorBlock(a);
3114 SetFS(sel);
3115
3116 return yyrc;
3117}
3118
3119inline ULONG APIENTRY WinQueryVersion(HAB a)
3120{
3121 ULONG yyrc;
3122 USHORT sel = GetFS();
3123
3124 yyrc = WinQueryVersion(a);
3125 SetFS(sel);
3126
3127 return yyrc;
3128}
3129
3130inline BOOL APIENTRY WinQueryWindowRect(HWND a, PRECTL b)
3131{
3132 BOOL yyrc;
3133 USHORT sel = GetFS();
3134
3135 yyrc = WinQueryWindowRect(a, b);
3136 SetFS(sel);
3137
3138 return yyrc;
3139}
3140
3141inline BOOL APIENTRY WinRegisterClass(HAB a, PCSZ b, PFNWP c, ULONG d, ULONG e)
3142{
3143 BOOL yyrc;
3144 USHORT sel = GetFS();
3145
3146 yyrc = WinRegisterClass(a, b, c, d, e);
3147 SetFS(sel);
3148
3149 return yyrc;
3150}
3151
3152inline BOOL APIENTRY WinReleasePS(HPS a)
3153{
3154 BOOL yyrc;
3155 USHORT sel = GetFS();
3156
3157 yyrc = WinReleasePS(a);
3158 SetFS(sel);
3159
3160 return yyrc;
3161}
3162
3163inline LONG APIENTRY WinScrollWindow(HWND a, LONG b, LONG c, CONST RECTL *d, CONST RECTL *e, HRGN f, PRECTL g, ULONG h)
3164{
3165 LONG yyrc;
3166 USHORT sel = GetFS();
3167
3168 yyrc = WinScrollWindow(a, b, c, d, e, f, g, h);
3169 SetFS(sel);
3170
3171 return yyrc;
3172}
3173
3174inline BOOL APIENTRY WinSetActiveWindow(HWND a, HWND b)
3175{
3176 BOOL yyrc;
3177 USHORT sel = GetFS();
3178
3179 yyrc = WinSetActiveWindow(a, b);
3180 SetFS(sel);
3181
3182 return yyrc;
3183}
3184
3185inline BOOL APIENTRY WinShowWindow(HWND a, BOOL b)
3186{
3187 BOOL yyrc;
3188 USHORT sel = GetFS();
3189
3190 yyrc = WinShowWindow(a, b);
3191 SetFS(sel);
3192
3193 return yyrc;
3194}
3195
3196inline BOOL APIENTRY WinTerminate(HAB a)
3197{
3198 BOOL yyrc;
3199 USHORT sel = GetFS();
3200
3201 yyrc = WinTerminate(a);
3202 SetFS(sel);
3203
3204 return yyrc;
3205}
3206
3207#endif
3208#ifdef INCL_WINWINDOWMGR
3209inline HENUM APIENTRY WinBeginEnumWindows(HWND a)
3210{
3211 HENUM yyrc;
3212 USHORT sel = GetFS();
3213
3214 yyrc = WinBeginEnumWindows(a);
3215 SetFS(sel);
3216
3217 return yyrc;
3218}
3219
3220inline BOOL APIENTRY WinEndEnumWindows(HENUM a)
3221{
3222 BOOL yyrc;
3223 USHORT sel = GetFS();
3224
3225 yyrc = WinEndEnumWindows(a);
3226 SetFS(sel);
3227
3228 return yyrc;
3229}
3230
3231inline LONG APIENTRY WinExcludeUpdateRegion(HPS a, HWND b)
3232{
3233 LONG yyrc;
3234 USHORT sel = GetFS();
3235
3236 yyrc = WinExcludeUpdateRegion(a, b);
3237 SetFS(sel);
3238
3239 return yyrc;
3240}
3241
3242inline HWND APIENTRY WinGetNextWindow(HENUM a)
3243{
3244 HWND yyrc;
3245 USHORT sel = GetFS();
3246
3247 yyrc = WinGetNextWindow(a);
3248 SetFS(sel);
3249
3250 return yyrc;
3251}
3252
3253inline HPS APIENTRY WinGetScreenPS(HWND a)
3254{
3255 HPS yyrc;
3256 USHORT sel = GetFS();
3257
3258 yyrc = WinGetScreenPS(a);
3259 SetFS(sel);
3260
3261 return yyrc;
3262}
3263
3264inline BOOL APIENTRY WinIsThreadActive(HAB a)
3265{
3266 BOOL yyrc;
3267 USHORT sel = GetFS();
3268
3269 yyrc = WinIsThreadActive(a);
3270 SetFS(sel);
3271
3272 return yyrc;
3273}
3274
3275inline BOOL APIENTRY WinLockVisRegions(HWND a, BOOL b)
3276{
3277 BOOL yyrc;
3278 USHORT sel = GetFS();
3279
3280 yyrc = WinLockVisRegions(a, b);
3281 SetFS(sel);
3282
3283 return yyrc;
3284}
3285
3286inline BOOL APIENTRY WinLockWindowUpdate(HWND a, HWND b)
3287{
3288 BOOL yyrc;
3289 USHORT sel = GetFS();
3290
3291 yyrc = WinLockWindowUpdate(a, b);
3292 SetFS(sel);
3293
3294 return yyrc;
3295}
3296
3297inline BOOL APIENTRY WinMapWindowPoints(HWND a, HWND b, PPOINTL c, LONG d)
3298{
3299 BOOL yyrc;
3300 USHORT sel = GetFS();
3301
3302 yyrc = WinMapWindowPoints(a, b, c, d);
3303 SetFS(sel);
3304
3305 return yyrc;
3306}
3307
3308inline HWND APIENTRY WinQueryActiveWindow(HWND a)
3309{
3310 HWND yyrc;
3311 USHORT sel = GetFS();
3312
3313 yyrc = WinQueryActiveWindow(a);
3314 SetFS(sel);
3315
3316 return yyrc;
3317}
3318
3319inline BOOL APIENTRY WinQueryClassInfo(HAB a, PCSZ b, PCLASSINFO c)
3320{
3321 BOOL yyrc;
3322 USHORT sel = GetFS();
3323
3324 yyrc = WinQueryClassInfo(a, b, c);
3325 SetFS(sel);
3326
3327 return yyrc;
3328}
3329
3330inline LONG APIENTRY WinQueryClassName(HWND a, LONG b, PCH c)
3331{
3332 LONG yyrc;
3333 USHORT sel = GetFS();
3334
3335 yyrc = WinQueryClassName(a, b, c);
3336 SetFS(sel);
3337
3338 return yyrc;
3339}
3340
3341inline BOOL APIENTRY WinQueryUpdateRect(HWND a, PRECTL b)
3342{
3343 BOOL yyrc;
3344 USHORT sel = GetFS();
3345
3346 yyrc = WinQueryUpdateRect(a, b);
3347 SetFS(sel);
3348
3349 return yyrc;
3350}
3351
3352inline LONG APIENTRY WinQueryUpdateRegion(HWND a, HRGN b)
3353{
3354 LONG yyrc;
3355 USHORT sel = GetFS();
3356
3357 yyrc = WinQueryUpdateRegion(a, b);
3358 SetFS(sel);
3359
3360 return yyrc;
3361}
3362
3363inline HWND APIENTRY WinQuerySysModalWindow(HWND a)
3364{
3365 HWND yyrc;
3366 USHORT sel = GetFS();
3367
3368 yyrc = WinQuerySysModalWindow(a);
3369 SetFS(sel);
3370
3371 return yyrc;
3372}
3373
3374inline HDC APIENTRY WinQueryWindowDC(HWND a)
3375{
3376 HDC yyrc;
3377 USHORT sel = GetFS();
3378
3379 yyrc = WinQueryWindowDC(a);
3380 SetFS(sel);
3381
3382 return yyrc;
3383}
3384
3385inline PVOID APIENTRY WinQueryWindowPtr(HWND a, LONG b)
3386{
3387 PVOID yyrc;
3388 USHORT sel = GetFS();
3389
3390 yyrc = WinQueryWindowPtr(a, b);
3391 SetFS(sel);
3392
3393 return yyrc;
3394}
3395
3396inline ULONG APIENTRY WinQueryWindowULong(HWND a, LONG b)
3397{
3398 ULONG yyrc;
3399 USHORT sel = GetFS();
3400
3401 yyrc = WinQueryWindowULong(a, b);
3402 SetFS(sel);
3403
3404 return yyrc;
3405}
3406
3407inline USHORT APIENTRY WinQueryWindowUShort(HWND a, LONG b)
3408{
3409 USHORT yyrc;
3410 USHORT sel = GetFS();
3411
3412 yyrc = WinQueryWindowUShort(a, b);
3413 SetFS(sel);
3414
3415 return yyrc;
3416}
3417
3418inline BOOL APIENTRY WinSetSysModalWindow(HWND a, HWND b)
3419{
3420 BOOL yyrc;
3421 USHORT sel = GetFS();
3422
3423 yyrc = WinSetSysModalWindow(a, b);
3424 SetFS(sel);
3425
3426 return yyrc;
3427}
3428
3429inline BOOL APIENTRY WinSetWindowBits(HWND a, LONG b, ULONG c, ULONG d)
3430{
3431 BOOL yyrc;
3432 USHORT sel = GetFS();
3433
3434 yyrc = WinSetWindowBits(a, b, c, d);
3435 SetFS(sel);
3436
3437 return yyrc;
3438}
3439
3440inline BOOL APIENTRY WinSetWindowPtr(HWND a, LONG b, PVOID c)
3441{
3442 BOOL yyrc;
3443 USHORT sel = GetFS();
3444
3445 yyrc = WinSetWindowPtr(a, b, c);
3446 SetFS(sel);
3447
3448 return yyrc;
3449}
3450
3451inline BOOL APIENTRY WinSetWindowULong(HWND a, LONG b, ULONG c)
3452{
3453 BOOL yyrc;
3454 USHORT sel = GetFS();
3455
3456 yyrc = WinSetWindowULong(a, b, c);
3457 SetFS(sel);
3458
3459 return yyrc;
3460}
3461
3462inline BOOL APIENTRY WinSetWindowUShort(HWND a, LONG b, USHORT c)
3463{
3464 BOOL yyrc;
3465 USHORT sel = GetFS();
3466
3467 yyrc = WinSetWindowUShort(a, b, c);
3468 SetFS(sel);
3469
3470 return yyrc;
3471}
3472
3473inline PFNWP APIENTRY WinSubclassWindow(HWND a, PFNWP b)
3474{
3475 PFNWP yyrc;
3476 USHORT sel = GetFS();
3477
3478 yyrc = WinSubclassWindow(a, b);
3479 SetFS(sel);
3480
3481 return yyrc;
3482}
3483
3484inline BOOL APIENTRY WinValidateRect(HWND a, CONST RECTL *b, BOOL c)
3485{
3486 BOOL yyrc;
3487 USHORT sel = GetFS();
3488
3489 yyrc = WinValidateRect(a, b, c);
3490 SetFS(sel);
3491
3492 return yyrc;
3493}
3494
3495inline BOOL APIENTRY WinValidateRegion(HWND a, HRGN b, BOOL c)
3496{
3497 BOOL yyrc;
3498 USHORT sel = GetFS();
3499
3500 yyrc = WinValidateRegion(a, b, c);
3501 SetFS(sel);
3502
3503 return yyrc;
3504}
3505
3506inline HWND APIENTRY WinWindowFromDC(HDC a)
3507{
3508 HWND yyrc;
3509 USHORT sel = GetFS();
3510
3511 yyrc = WinWindowFromDC(a);
3512 SetFS(sel);
3513
3514 return yyrc;
3515}
3516
3517inline HWND APIENTRY WinWindowFromPoint(HWND a, CONST POINTL *b, BOOL c)
3518{
3519 HWND yyrc;
3520 USHORT sel = GetFS();
3521
3522 yyrc = WinWindowFromPoint(a, b, c);
3523 SetFS(sel);
3524
3525 return yyrc;
3526}
3527
3528#endif
3529#ifdef INCL_WINACCELERATORS
3530inline ULONG APIENTRY WinCopyAccelTable(HACCEL a, PACCELTABLE b, ULONG c)
3531{
3532 ULONG yyrc;
3533 USHORT sel = GetFS();
3534
3535 yyrc = WinCopyAccelTable(a, b, c);
3536 SetFS(sel);
3537
3538 return yyrc;
3539}
3540
3541inline HACCEL APIENTRY WinCreateAccelTable(HAB a, PACCELTABLE b)
3542{
3543 HACCEL yyrc;
3544 USHORT sel = GetFS();
3545
3546 yyrc = WinCreateAccelTable(a, b);
3547 SetFS(sel);
3548
3549 return yyrc;
3550}
3551
3552inline BOOL APIENTRY WinDestroyAccelTable(HACCEL a)
3553{
3554 BOOL yyrc;
3555 USHORT sel = GetFS();
3556
3557 yyrc = WinDestroyAccelTable(a);
3558 SetFS(sel);
3559
3560 return yyrc;
3561}
3562
3563inline HACCEL APIENTRY WinLoadAccelTable(HAB a, HMODULE b, ULONG c)
3564{
3565 HACCEL yyrc;
3566 USHORT sel = GetFS();
3567
3568 yyrc = WinLoadAccelTable(a, b, c);
3569 SetFS(sel);
3570
3571 return yyrc;
3572}
3573
3574inline HACCEL APIENTRY WinQueryAccelTable(HAB a, HWND b)
3575{
3576 HACCEL yyrc;
3577 USHORT sel = GetFS();
3578
3579 yyrc = WinQueryAccelTable(a, b);
3580 SetFS(sel);
3581
3582 return yyrc;
3583}
3584
3585inline BOOL APIENTRY WinSetAccelTable(HAB a, HACCEL b, HWND c)
3586{
3587 BOOL yyrc;
3588 USHORT sel = GetFS();
3589
3590 yyrc = WinSetAccelTable(a, b, c);
3591 SetFS(sel);
3592
3593 return yyrc;
3594}
3595
3596inline BOOL APIENTRY WinTranslateAccel(HAB a, HWND b, HACCEL c, PQMSG d)
3597{
3598 BOOL yyrc;
3599 USHORT sel = GetFS();
3600
3601 yyrc = WinTranslateAccel(a, b, c, d);
3602 SetFS(sel);
3603
3604 return yyrc;
3605}
3606
3607#endif
3608#ifdef INCL_WINATOM
3609inline ATOM APIENTRY WinAddAtom(HATOMTBL a, PCSZ b)
3610{
3611 ATOM yyrc;
3612 USHORT sel = GetFS();
3613
3614 yyrc = WinAddAtom(a, b);
3615 SetFS(sel);
3616
3617 return yyrc;
3618}
3619
3620inline HATOMTBL APIENTRY WinCreateAtomTable(ULONG a, ULONG b)
3621{
3622 HATOMTBL yyrc;
3623 USHORT sel = GetFS();
3624
3625 yyrc = WinCreateAtomTable(a, b);
3626 SetFS(sel);
3627
3628 return yyrc;
3629}
3630
3631inline ATOM APIENTRY WinDeleteAtom(HATOMTBL a, ATOM b)
3632{
3633 ATOM yyrc;
3634 USHORT sel = GetFS();
3635
3636 yyrc = WinDeleteAtom(a, b);
3637 SetFS(sel);
3638
3639 return yyrc;
3640}
3641
3642inline HATOMTBL APIENTRY WinDestroyAtomTable(HATOMTBL a)
3643{
3644 HATOMTBL yyrc;
3645 USHORT sel = GetFS();
3646
3647 yyrc = WinDestroyAtomTable(a);
3648 SetFS(sel);
3649
3650 return yyrc;
3651}
3652
3653inline ATOM APIENTRY WinFindAtom(HATOMTBL a, PCSZ b)
3654{
3655 ATOM yyrc;
3656 USHORT sel = GetFS();
3657
3658 yyrc = WinFindAtom(a, b);
3659 SetFS(sel);
3660
3661 return yyrc;
3662}
3663
3664inline ULONG APIENTRY WinQueryAtomLength(HATOMTBL a, ATOM b)
3665{
3666 ULONG yyrc;
3667 USHORT sel = GetFS();
3668
3669 yyrc = WinQueryAtomLength(a, b);
3670 SetFS(sel);
3671
3672 return yyrc;
3673}
3674
3675inline ULONG APIENTRY WinQueryAtomName(HATOMTBL a, ATOM b, PSZ c, ULONG d)
3676{
3677 ULONG yyrc;
3678 USHORT sel = GetFS();
3679
3680 yyrc = WinQueryAtomName(a, b, c, d);
3681 SetFS(sel);
3682
3683 return yyrc;
3684}
3685
3686inline ULONG APIENTRY WinQueryAtomUsage(HATOMTBL a, ATOM b)
3687{
3688 ULONG yyrc;
3689 USHORT sel = GetFS();
3690
3691 yyrc = WinQueryAtomUsage(a, b);
3692 SetFS(sel);
3693
3694 return yyrc;
3695}
3696
3697inline HATOMTBL APIENTRY WinQuerySystemAtomTable()
3698{
3699 HATOMTBL yyrc;
3700 USHORT sel = GetFS();
3701
3702 yyrc = WinQuerySystemAtomTable();
3703 SetFS(sel);
3704
3705 return yyrc;
3706}
3707
3708#endif
3709#ifdef INCL_WINCLIPBOARD
3710inline BOOL APIENTRY WinCloseClipbrd(HAB a)
3711{
3712 BOOL yyrc;
3713 USHORT sel = GetFS();
3714
3715 yyrc = WinCloseClipbrd(a);
3716 SetFS(sel);
3717
3718 return yyrc;
3719}
3720
3721inline BOOL APIENTRY WinEmptyClipbrd(HAB a)
3722{
3723 BOOL yyrc;
3724 USHORT sel = GetFS();
3725
3726 yyrc = WinEmptyClipbrd(a);
3727 SetFS(sel);
3728
3729 return yyrc;
3730}
3731
3732inline ULONG APIENTRY WinEnumClipbrdFmts(HAB a, ULONG b)
3733{
3734 ULONG yyrc;
3735 USHORT sel = GetFS();
3736
3737 yyrc = WinEnumClipbrdFmts(a, b);
3738 SetFS(sel);
3739
3740 return yyrc;
3741}
3742
3743inline BOOL APIENTRY WinOpenClipbrd(HAB a)
3744{
3745 BOOL yyrc;
3746 USHORT sel = GetFS();
3747
3748 yyrc = WinOpenClipbrd(a);
3749 SetFS(sel);
3750
3751 return yyrc;
3752}
3753
3754inline ULONG APIENTRY WinQueryClipbrdData(HAB a, ULONG b)
3755{
3756 ULONG yyrc;
3757 USHORT sel = GetFS();
3758
3759 yyrc = WinQueryClipbrdData(a, b);
3760 SetFS(sel);
3761
3762 return yyrc;
3763}
3764
3765inline BOOL APIENTRY WinQueryClipbrdFmtInfo(HAB a, ULONG b, PULONG c)
3766{
3767 BOOL yyrc;
3768 USHORT sel = GetFS();
3769
3770 yyrc = WinQueryClipbrdFmtInfo(a, b, c);
3771 SetFS(sel);
3772
3773 return yyrc;
3774}
3775
3776inline HWND APIENTRY WinQueryClipbrdOwner(HAB a)
3777{
3778 HWND yyrc;
3779 USHORT sel = GetFS();
3780
3781 yyrc = WinQueryClipbrdOwner(a);
3782 SetFS(sel);
3783
3784 return yyrc;
3785}
3786
3787inline HWND APIENTRY WinQueryClipbrdViewer(HAB a)
3788{
3789 HWND yyrc;
3790 USHORT sel = GetFS();
3791
3792 yyrc = WinQueryClipbrdViewer(a);
3793 SetFS(sel);
3794
3795 return yyrc;
3796}
3797
3798inline BOOL APIENTRY WinSetClipbrdData(HAB a, ULONG b, ULONG c, ULONG d)
3799{
3800 BOOL yyrc;
3801 USHORT sel = GetFS();
3802
3803 yyrc = WinSetClipbrdData(a, b, c, d);
3804 SetFS(sel);
3805
3806 return yyrc;
3807}
3808
3809inline BOOL APIENTRY WinSetClipbrdOwner(HAB a, HWND b)
3810{
3811 BOOL yyrc;
3812 USHORT sel = GetFS();
3813
3814 yyrc = WinSetClipbrdOwner(a, b);
3815 SetFS(sel);
3816
3817 return yyrc;
3818}
3819
3820inline BOOL APIENTRY WinSetClipbrdViewer(HAB a, HWND b)
3821{
3822 BOOL yyrc;
3823 USHORT sel = GetFS();
3824
3825 yyrc = WinSetClipbrdViewer(a, b);
3826 SetFS(sel);
3827
3828 return yyrc;
3829}
3830
3831#endif
3832#ifdef INCL_WINDDE
3833inline BOOL APIENTRY WinDdeInitiate(HWND a, PCSZ b, PCSZ c, CONST CONVCONTEXT *d)
3834{
3835 BOOL yyrc;
3836 USHORT sel = GetFS();
3837
3838 yyrc = WinDdeInitiate(a, b, c, d);
3839 SetFS(sel);
3840
3841 return yyrc;
3842}
3843
3844inline BOOL APIENTRY WinDdePostMsg(HWND a, HWND b, ULONG c, CONST DDESTRUCT *d, ULONG e)
3845{
3846 BOOL yyrc;
3847 USHORT sel = GetFS();
3848
3849 yyrc = WinDdePostMsg(a, b, c, d, e);
3850 SetFS(sel);
3851
3852 return yyrc;
3853}
3854
3855inline MRESULT APIENTRY WinDdeRespond(HWND a, HWND b, PCSZ c, PCSZ d, CONST CONVCONTEXT *e)
3856{
3857 MRESULT yyrc;
3858 USHORT sel = GetFS();
3859
3860 yyrc = WinDdeRespond(a, b, c, d, e);
3861 SetFS(sel);
3862
3863 return yyrc;
3864}
3865
3866#endif
3867#ifdef INCL_WINCOUNTRY
3868inline ULONG APIENTRY WinCompareStrings(HAB a, ULONG b, ULONG c, PCSZ d, PCSZ e, ULONG f)
3869{
3870 ULONG yyrc;
3871 USHORT sel = GetFS();
3872
3873 yyrc = WinCompareStrings(a, b, c, d, e, f);
3874 SetFS(sel);
3875
3876 return yyrc;
3877}
3878
3879inline UCHAR APIENTRY WinCpTranslateChar(HAB a, ULONG b, UCHAR c, ULONG d)
3880{
3881 UCHAR yyrc;
3882 USHORT sel = GetFS();
3883
3884 yyrc = WinCpTranslateChar(a, b, c, d);
3885 SetFS(sel);
3886
3887 return yyrc;
3888}
3889
3890inline BOOL APIENTRY WinCpTranslateString(HAB a, ULONG b, PCSZ c, ULONG d, ULONG e, PSZ f)
3891{
3892 BOOL yyrc;
3893 USHORT sel = GetFS();
3894
3895 yyrc = WinCpTranslateString(a, b, c, d, e, f);
3896 SetFS(sel);
3897
3898 return yyrc;
3899}
3900
3901inline PSZ APIENTRY WinNextChar(HAB a, ULONG b, ULONG c, PCSZ d)
3902{
3903 PSZ yyrc;
3904 USHORT sel = GetFS();
3905
3906 yyrc = WinNextChar(a, b, c, d);
3907 SetFS(sel);
3908
3909 return yyrc;
3910}
3911
3912inline PSZ APIENTRY WinPrevChar(HAB a, ULONG b, ULONG c, PCSZ d, PCSZ e)
3913{
3914 PSZ yyrc;
3915 USHORT sel = GetFS();
3916
3917 yyrc = WinPrevChar(a, b, c, d, e);
3918 SetFS(sel);
3919
3920 return yyrc;
3921}
3922
3923inline ULONG APIENTRY WinQueryCp(HMQ a)
3924{
3925 ULONG yyrc;
3926 USHORT sel = GetFS();
3927
3928 yyrc = WinQueryCp(a);
3929 SetFS(sel);
3930
3931 return yyrc;
3932}
3933
3934inline ULONG APIENTRY WinQueryCpList(HAB a, ULONG b, PULONG c)
3935{
3936 ULONG yyrc;
3937 USHORT sel = GetFS();
3938
3939 yyrc = WinQueryCpList(a, b, c);
3940 SetFS(sel);
3941
3942 return yyrc;
3943}
3944
3945inline BOOL APIENTRY WinSetCp(HMQ a, ULONG b)
3946{
3947 BOOL yyrc;
3948 USHORT sel = GetFS();
3949
3950 yyrc = WinSetCp(a, b);
3951 SetFS(sel);
3952
3953 return yyrc;
3954}
3955
3956inline ULONG APIENTRY WinUpper(HAB a, ULONG b, ULONG c, PSZ d)
3957{
3958 ULONG yyrc;
3959 USHORT sel = GetFS();
3960
3961 yyrc = WinUpper(a, b, c, d);
3962 SetFS(sel);
3963
3964 return yyrc;
3965}
3966
3967inline ULONG APIENTRY WinUpperChar(HAB a, ULONG b, ULONG c, ULONG d)
3968{
3969 ULONG yyrc;
3970 USHORT sel = GetFS();
3971
3972 yyrc = WinUpperChar(a, b, c, d);
3973 SetFS(sel);
3974
3975 return yyrc;
3976}
3977
3978#endif
3979#ifdef INCL_WINCURSORS
3980inline BOOL APIENTRY WinCreateCursor(HWND a, LONG b, LONG c, LONG d, LONG e, ULONG f, PRECTL g)
3981{
3982 BOOL yyrc;
3983 USHORT sel = GetFS();
3984
3985 yyrc = WinCreateCursor(a, b, c, d, e, f, g);
3986 SetFS(sel);
3987
3988 return yyrc;
3989}
3990
3991inline BOOL APIENTRY WinDestroyCursor(HWND a)
3992{
3993 BOOL yyrc;
3994 USHORT sel = GetFS();
3995
3996 yyrc = WinDestroyCursor(a);
3997 SetFS(sel);
3998
3999 return yyrc;
4000}
4001
4002inline BOOL APIENTRY WinShowCursor(HWND a, BOOL b)
4003{
4004 BOOL yyrc;
4005 USHORT sel = GetFS();
4006
4007 yyrc = WinShowCursor(a, b);
4008 SetFS(sel);
4009
4010 return yyrc;
4011}
4012
4013inline BOOL APIENTRY WinQueryCursorInfo(HWND a, PCURSORINFO b)
4014{
4015 BOOL yyrc;
4016 USHORT sel = GetFS();
4017
4018 yyrc = WinQueryCursorInfo(a, b);
4019 SetFS(sel);
4020
4021 return yyrc;
4022}
4023
4024#endif
4025#ifdef INCL_WINDESKTOP
4026inline BOOL APIENTRY WinQueryDesktopBkgnd(HWND a, PDESKTOP b)
4027{
4028 BOOL yyrc;
4029 USHORT sel = GetFS();
4030
4031 yyrc = WinQueryDesktopBkgnd(a, b);
4032 SetFS(sel);
4033
4034 return yyrc;
4035}
4036
4037inline HBITMAP APIENTRY WinSetDesktopBkgnd(HWND a, CONST DESKTOP *b)
4038{
4039 HBITMAP yyrc;
4040 USHORT sel = GetFS();
4041
4042 yyrc = WinSetDesktopBkgnd(a, b);
4043 SetFS(sel);
4044
4045 return yyrc;
4046}
4047
4048#endif
4049#ifdef INCL_WINDIALOGS
4050inline BOOL APIENTRY WinAlarm(HWND a, ULONG b)
4051{
4052 BOOL yyrc;
4053 USHORT sel = GetFS();
4054
4055 yyrc = WinAlarm(a, b);
4056 SetFS(sel);
4057
4058 return yyrc;
4059}
4060
4061inline MRESULT APIENTRY WinDefDlgProc(HWND a, ULONG b, MPARAM c, MPARAM d)
4062{
4063 MRESULT yyrc;
4064 USHORT sel = GetFS();
4065
4066 yyrc = WinDefDlgProc(a, b, c, d);
4067 SetFS(sel);
4068
4069 return yyrc;
4070}
4071
4072inline BOOL APIENTRY WinDismissDlg(HWND a, ULONG b)
4073{
4074 BOOL yyrc;
4075 USHORT sel = GetFS();
4076
4077 yyrc = WinDismissDlg(a, b);
4078 SetFS(sel);
4079
4080 return yyrc;
4081}
4082
4083inline ULONG APIENTRY WinDlgBox(HWND a, HWND b, PFNWP c, HMODULE d, ULONG e, PVOID f)
4084{
4085 ULONG yyrc;
4086 USHORT sel = GetFS();
4087
4088 yyrc = WinDlgBox(a, b, c, d, e, f);
4089 SetFS(sel);
4090
4091 return yyrc;
4092}
4093
4094inline BOOL APIENTRY WinGetDlgMsg(HWND a, PQMSG b)
4095{
4096 BOOL yyrc;
4097 USHORT sel = GetFS();
4098
4099 yyrc = WinGetDlgMsg(a, b);
4100 SetFS(sel);
4101
4102 return yyrc;
4103}
4104
4105inline HWND APIENTRY WinLoadDlg(HWND a, HWND b, PFNWP c, HMODULE d, ULONG e, PVOID f)
4106{
4107 HWND yyrc;
4108 USHORT sel = GetFS();
4109
4110 yyrc = WinLoadDlg(a, b, c, d, e, f);
4111 SetFS(sel);
4112
4113 return yyrc;
4114}
4115
4116inline ULONG APIENTRY WinMessageBox(HWND a, HWND b, PCSZ c, PCSZ d, ULONG e, ULONG f)
4117{
4118 ULONG yyrc;
4119 USHORT sel = GetFS();
4120
4121 yyrc = WinMessageBox(a, b, c, d, e, f);
4122 SetFS(sel);
4123
4124 return yyrc;
4125}
4126
4127inline ULONG APIENTRY WinMessageBox2(HWND a, HWND b, PCSZ c, PCSZ d, ULONG e, PMB2INFO f)
4128{
4129 ULONG yyrc;
4130 USHORT sel = GetFS();
4131
4132 yyrc = WinMessageBox2(a, b, c, d, e, f);
4133 SetFS(sel);
4134
4135 return yyrc;
4136}
4137
4138inline BOOL APIENTRY WinQueryDlgItemShort(HWND a, ULONG b, PSHORT c, BOOL d)
4139{
4140 BOOL yyrc;
4141 USHORT sel = GetFS();
4142
4143 yyrc = WinQueryDlgItemShort(a, b, c, d);
4144 SetFS(sel);
4145
4146 return yyrc;
4147}
4148
4149inline ULONG APIENTRY WinQueryDlgItemText(HWND a, ULONG b, LONG c, PSZ d)
4150{
4151 ULONG yyrc;
4152 USHORT sel = GetFS();
4153
4154 yyrc = WinQueryDlgItemText(a, b, c, d);
4155 SetFS(sel);
4156
4157 return yyrc;
4158}
4159
4160inline LONG APIENTRY WinQueryDlgItemTextLength(HWND a, ULONG b)
4161{
4162 LONG yyrc;
4163 USHORT sel = GetFS();
4164
4165 yyrc = WinQueryDlgItemTextLength(a, b);
4166 SetFS(sel);
4167
4168 return yyrc;
4169}
4170
4171inline BOOL APIENTRY WinSetDlgItemShort(HWND a, ULONG b, USHORT c, BOOL d)
4172{
4173 BOOL yyrc;
4174 USHORT sel = GetFS();
4175
4176 yyrc = WinSetDlgItemShort(a, b, c, d);
4177 SetFS(sel);
4178
4179 return yyrc;
4180}
4181
4182inline BOOL APIENTRY WinSetDlgItemText(HWND a, ULONG b, PCSZ c)
4183{
4184 BOOL yyrc;
4185 USHORT sel = GetFS();
4186
4187 yyrc = WinSetDlgItemText(a, b, c);
4188 SetFS(sel);
4189
4190 return yyrc;
4191}
4192
4193inline HWND APIENTRY WinCreateDlg(HWND a, HWND b, PFNWP c, PDLGTEMPLATE d, PVOID e)
4194{
4195 HWND yyrc;
4196 USHORT sel = GetFS();
4197
4198 yyrc = WinCreateDlg(a, b, c, d, e);
4199 SetFS(sel);
4200
4201 return yyrc;
4202}
4203
4204inline HWND APIENTRY WinEnumDlgItem(HWND a, HWND b, ULONG c)
4205{
4206 HWND yyrc;
4207 USHORT sel = GetFS();
4208
4209 yyrc = WinEnumDlgItem(a, b, c);
4210 SetFS(sel);
4211
4212 return yyrc;
4213}
4214
4215inline BOOL APIENTRY WinMapDlgPoints(HWND a, PPOINTL b, ULONG c, BOOL d)
4216{
4217 BOOL yyrc;
4218 USHORT sel = GetFS();
4219
4220 yyrc = WinMapDlgPoints(a, b, c, d);
4221 SetFS(sel);
4222
4223 return yyrc;
4224}
4225
4226inline ULONG APIENTRY WinProcessDlg(HWND a)
4227{
4228 ULONG yyrc;
4229 USHORT sel = GetFS();
4230
4231 yyrc = WinProcessDlg(a);
4232 SetFS(sel);
4233
4234 return yyrc;
4235}
4236
4237inline MRESULT APIENTRY WinSendDlgItemMsg(HWND a, ULONG b, ULONG c, MPARAM d, MPARAM e)
4238{
4239 MRESULT yyrc;
4240 USHORT sel = GetFS();
4241
4242 yyrc = WinSendDlgItemMsg(a, b, c, d, e);
4243 SetFS(sel);
4244
4245 return yyrc;
4246}
4247
4248inline LONG APIENTRY WinSubstituteStrings(HWND a, PCSZ b, LONG c, PSZ d)
4249{
4250 LONG yyrc;
4251 USHORT sel = GetFS();
4252
4253 yyrc = WinSubstituteStrings(a, b, c, d);
4254 SetFS(sel);
4255
4256 return yyrc;
4257}
4258
4259#endif
4260#ifdef INCL_WINERRORS
4261inline ERRORID APIENTRY WinGetLastError(HAB a)
4262{
4263 ERRORID yyrc;
4264 USHORT sel = GetFS();
4265
4266 yyrc = WinGetLastError(a);
4267 SetFS(sel);
4268
4269 return yyrc;
4270}
4271
4272inline BOOL APIENTRY WinFreeErrorInfo(PERRINFO a)
4273{
4274 BOOL yyrc;
4275 USHORT sel = GetFS();
4276
4277 yyrc = WinFreeErrorInfo(a);
4278 SetFS(sel);
4279
4280 return yyrc;
4281}
4282
4283inline PERRINFO APIENTRY WinGetErrorInfo(HAB a)
4284{
4285 PERRINFO yyrc;
4286 USHORT sel = GetFS();
4287
4288 yyrc = WinGetErrorInfo(a);
4289 SetFS(sel);
4290
4291 return yyrc;
4292}
4293
4294#endif
4295#ifdef INCL_WINHOOKS
4296inline BOOL APIENTRY WinCallMsgFilter(HAB a, PQMSG b, ULONG c)
4297{
4298 BOOL yyrc;
4299 USHORT sel = GetFS();
4300
4301 yyrc = WinCallMsgFilter(a, b, c);
4302 SetFS(sel);
4303
4304 return yyrc;
4305}
4306
4307inline BOOL APIENTRY WinReleaseHook(HAB a, HMQ b, LONG c, PFN d, HMODULE e)
4308{
4309 BOOL yyrc;
4310 USHORT sel = GetFS();
4311
4312 yyrc = WinReleaseHook(a, b, c, d, e);
4313 SetFS(sel);
4314
4315 return yyrc;
4316}
4317
4318inline BOOL APIENTRY WinSetHook(HAB a, HMQ b, LONG c, PFN d, HMODULE e)
4319{
4320 BOOL yyrc;
4321 USHORT sel = GetFS();
4322
4323 yyrc = WinSetHook(a, b, c, d, e);
4324 SetFS(sel);
4325
4326 return yyrc;
4327}
4328
4329#endif
4330#ifdef INCL_WININPUT
4331inline BOOL APIENTRY WinFocusChange(HWND a, HWND b, ULONG c)
4332{
4333 BOOL yyrc;
4334 USHORT sel = GetFS();
4335
4336 yyrc = WinFocusChange(a, b, c);
4337 SetFS(sel);
4338
4339 return yyrc;
4340}
4341
4342inline BOOL APIENTRY WinLockupSystem(HAB a)
4343{
4344 BOOL yyrc;
4345 USHORT sel = GetFS();
4346
4347 yyrc = WinLockupSystem(a);
4348 SetFS(sel);
4349
4350 return yyrc;
4351}
4352
4353inline BOOL APIENTRY WinSetFocus(HWND a, HWND b)
4354{
4355 BOOL yyrc;
4356 USHORT sel = GetFS();
4357
4358 yyrc = WinSetFocus(a, b);
4359 SetFS(sel);
4360
4361 return yyrc;
4362}
4363
4364inline BOOL APIENTRY WinUnlockSystem(HAB a, PCSZ b)
4365{
4366 BOOL yyrc;
4367 USHORT sel = GetFS();
4368
4369 yyrc = WinUnlockSystem(a, b);
4370 SetFS(sel);
4371
4372 return yyrc;
4373}
4374
4375inline BOOL APIENTRY WinCheckInput(HAB a)
4376{
4377 BOOL yyrc;
4378 USHORT sel = GetFS();
4379
4380 yyrc = WinCheckInput(a);
4381 SetFS(sel);
4382
4383 return yyrc;
4384}
4385
4386inline BOOL APIENTRY WinEnablePhysInput(HWND a, BOOL b)
4387{
4388 BOOL yyrc;
4389 USHORT sel = GetFS();
4390
4391 yyrc = WinEnablePhysInput(a, b);
4392 SetFS(sel);
4393
4394 return yyrc;
4395}
4396
4397inline LONG APIENTRY WinGetKeyState(HWND a, LONG b)
4398{
4399 LONG yyrc;
4400 USHORT sel = GetFS();
4401
4402 yyrc = WinGetKeyState(a, b);
4403 SetFS(sel);
4404
4405 return yyrc;
4406}
4407
4408inline LONG APIENTRY WinGetPhysKeyState(HWND a, LONG b)
4409{
4410 LONG yyrc;
4411 USHORT sel = GetFS();
4412
4413 yyrc = WinGetPhysKeyState(a, b);
4414 SetFS(sel);
4415
4416 return yyrc;
4417}
4418
4419inline BOOL APIENTRY WinIsPhysInputEnabled(HWND a)
4420{
4421 BOOL yyrc;
4422 USHORT sel = GetFS();
4423
4424 yyrc = WinIsPhysInputEnabled(a);
4425 SetFS(sel);
4426
4427 return yyrc;
4428}
4429
4430inline HWND APIENTRY WinQueryCapture(HWND a)
4431{
4432 HWND yyrc;
4433 USHORT sel = GetFS();
4434
4435 yyrc = WinQueryCapture(a);
4436 SetFS(sel);
4437
4438 return yyrc;
4439}
4440
4441inline HWND APIENTRY WinQueryFocus(HWND a)
4442{
4443 HWND yyrc;
4444 USHORT sel = GetFS();
4445
4446 yyrc = WinQueryFocus(a);
4447 SetFS(sel);
4448
4449 return yyrc;
4450}
4451
4452inline ULONG APIENTRY WinQueryVisibleRegion(HWND a, HRGN b)
4453{
4454 ULONG yyrc;
4455 USHORT sel = GetFS();
4456
4457 yyrc = WinQueryVisibleRegion(a, b);
4458 SetFS(sel);
4459
4460 return yyrc;
4461}
4462
4463inline BOOL APIENTRY WinSetCapture(HWND a, HWND b)
4464{
4465 BOOL yyrc;
4466 USHORT sel = GetFS();
4467
4468 yyrc = WinSetCapture(a, b);
4469 SetFS(sel);
4470
4471 return yyrc;
4472}
4473
4474inline BOOL APIENTRY WinSetKeyboardStateTable(HWND a, PBYTE b, BOOL c)
4475{
4476 BOOL yyrc;
4477 USHORT sel = GetFS();
4478
4479 yyrc = WinSetKeyboardStateTable(a, b, c);
4480 SetFS(sel);
4481
4482 return yyrc;
4483}
4484
4485inline BOOL APIENTRY WinSetVisibleRegionNotify(HWND a, BOOL b)
4486{
4487 BOOL yyrc;
4488 USHORT sel = GetFS();
4489
4490 yyrc = WinSetVisibleRegionNotify(a, b);
4491 SetFS(sel);
4492
4493 return yyrc;
4494}
4495
4496#endif
4497#ifdef INCL_WINLOAD
4498inline BOOL APIENTRY WinDeleteLibrary(HAB a, HLIB b)
4499{
4500 BOOL yyrc;
4501 USHORT sel = GetFS();
4502
4503 yyrc = WinDeleteLibrary(a, b);
4504 SetFS(sel);
4505
4506 return yyrc;
4507}
4508
4509inline BOOL APIENTRY WinDeleteProcedure(HAB a, PFNWP b)
4510{
4511 BOOL yyrc;
4512 USHORT sel = GetFS();
4513
4514 yyrc = WinDeleteProcedure(a, b);
4515 SetFS(sel);
4516
4517 return yyrc;
4518}
4519
4520inline HLIB APIENTRY WinLoadLibrary(HAB a, PCSZ b)
4521{
4522 HLIB yyrc;
4523 USHORT sel = GetFS();
4524
4525 yyrc = WinLoadLibrary(a, b);
4526 SetFS(sel);
4527
4528 return yyrc;
4529}
4530
4531inline PFNWP APIENTRY WinLoadProcedure(HAB a, HLIB b, PSZ c)
4532{
4533 PFNWP yyrc;
4534 USHORT sel = GetFS();
4535
4536 yyrc = WinLoadProcedure(a, b, c);
4537 SetFS(sel);
4538
4539 return yyrc;
4540}
4541
4542#endif
4543#ifdef INCL_WINMENUS
4544inline HWND APIENTRY WinCreateMenu(HWND a, PVOID b)
4545{
4546 HWND yyrc;
4547 USHORT sel = GetFS();
4548
4549 yyrc = WinCreateMenu(a, b);
4550 SetFS(sel);
4551
4552 return yyrc;
4553}
4554
4555inline HWND APIENTRY WinLoadMenu(HWND a, HMODULE b, ULONG c)
4556{
4557 HWND yyrc;
4558 USHORT sel = GetFS();
4559
4560 yyrc = WinLoadMenu(a, b, c);
4561 SetFS(sel);
4562
4563 return yyrc;
4564}
4565
4566inline BOOL APIENTRY WinPopupMenu(HWND a, HWND b, HWND c, LONG d, LONG e, LONG f, ULONG g)
4567{
4568 BOOL yyrc;
4569 USHORT sel = GetFS();
4570
4571 yyrc = WinPopupMenu(a, b, c, d, e, f, g);
4572 SetFS(sel);
4573
4574 return yyrc;
4575}
4576
4577#endif
4578#ifdef INCL_WINMESSAGEMGR
4579inline BOOL APIENTRY WinBroadcastMsg(HWND a, ULONG b, MPARAM c, MPARAM d, ULONG e)
4580{
4581 BOOL yyrc;
4582 USHORT sel = GetFS();
4583
4584 yyrc = WinBroadcastMsg(a, b, c, d, e);
4585 SetFS(sel);
4586
4587 return yyrc;
4588}
4589
4590inline BOOL APIENTRY WinInSendMsg(HAB a)
4591{
4592 BOOL yyrc;
4593 USHORT sel = GetFS();
4594
4595 yyrc = WinInSendMsg(a);
4596 SetFS(sel);
4597
4598 return yyrc;
4599}
4600
4601inline BOOL APIENTRY WinPostQueueMsg(HMQ a, ULONG b, MPARAM c, MPARAM d)
4602{
4603 BOOL yyrc;
4604 USHORT sel = GetFS();
4605
4606 yyrc = WinPostQueueMsg(a, b, c, d);
4607 SetFS(sel);
4608
4609 return yyrc;
4610}
4611
4612inline BOOL APIENTRY WinQueryMsgPos(HAB a, PPOINTL b)
4613{
4614 BOOL yyrc;
4615 USHORT sel = GetFS();
4616
4617 yyrc = WinQueryMsgPos(a, b);
4618 SetFS(sel);
4619
4620 return yyrc;
4621}
4622
4623inline ULONG APIENTRY WinQueryMsgTime(HAB a)
4624{
4625 ULONG yyrc;
4626 USHORT sel = GetFS();
4627
4628 yyrc = WinQueryMsgTime(a);
4629 SetFS(sel);
4630
4631 return yyrc;
4632}
4633
4634inline ULONG APIENTRY WinQueryQueueStatus(HWND a)
4635{
4636 ULONG yyrc;
4637 USHORT sel = GetFS();
4638
4639 yyrc = WinQueryQueueStatus(a);
4640 SetFS(sel);
4641
4642 return yyrc;
4643}
4644
4645inline ULONG APIENTRY WinRequestMutexSem(HMTX a, ULONG b)
4646{
4647 ULONG yyrc;
4648 USHORT sel = GetFS();
4649
4650 yyrc = WinRequestMutexSem(a, b);
4651 SetFS(sel);
4652
4653 return yyrc;
4654}
4655
4656inline BOOL APIENTRY WinSetClassMsgInterest(HAB a, PCSZ b, ULONG c, LONG d)
4657{
4658 BOOL yyrc;
4659 USHORT sel = GetFS();
4660
4661 yyrc = WinSetClassMsgInterest(a, b, c, d);
4662 SetFS(sel);
4663
4664 return yyrc;
4665}
4666
4667inline BOOL APIENTRY WinSetMsgInterest(HWND a, ULONG b, LONG c)
4668{
4669 BOOL yyrc;
4670 USHORT sel = GetFS();
4671
4672 yyrc = WinSetMsgInterest(a, b, c);
4673 SetFS(sel);
4674
4675 return yyrc;
4676}
4677
4678inline ULONG APIENTRY WinWaitEventSem(HEV a, ULONG b)
4679{
4680 ULONG yyrc;
4681 USHORT sel = GetFS();
4682
4683 yyrc = WinWaitEventSem(a, b);
4684 SetFS(sel);
4685
4686 return yyrc;
4687}
4688
4689inline BOOL APIENTRY WinWaitMsg(HAB a, ULONG b, ULONG c)
4690{
4691 BOOL yyrc;
4692 USHORT sel = GetFS();
4693
4694 yyrc = WinWaitMsg(a, b, c);
4695 SetFS(sel);
4696
4697 return yyrc;
4698}
4699
4700inline ULONG APIENTRY WinWaitMuxWaitSem(HMUX a, ULONG b, PULONG c)
4701{
4702 ULONG yyrc;
4703 USHORT sel = GetFS();
4704
4705 yyrc = WinWaitMuxWaitSem(a, b, c);
4706 SetFS(sel);
4707
4708 return yyrc;
4709}
4710
4711#endif
4712#ifdef INCL_WINPALETTE
4713inline LONG APIENTRY WinRealizePalette(HWND a, HPS b, PULONG c)
4714{
4715 LONG yyrc;
4716 USHORT sel = GetFS();
4717
4718 yyrc = WinRealizePalette(a, b, c);
4719 SetFS(sel);
4720
4721 return yyrc;
4722}
4723
4724#endif
4725#ifdef INCL_WINPOINTERS
4726inline HPOINTER APIENTRY WinCreatePointer(HWND a, HBITMAP b, BOOL c, LONG d, LONG e)
4727{
4728 HPOINTER yyrc;
4729 USHORT sel = GetFS();
4730
4731 yyrc = WinCreatePointer(a, b, c, d, e);
4732 SetFS(sel);
4733
4734 return yyrc;
4735}
4736
4737inline HPOINTER APIENTRY WinCreatePointerIndirect(HWND a, CONST POINTERINFO *b)
4738{
4739 HPOINTER yyrc;
4740 USHORT sel = GetFS();
4741
4742 yyrc = WinCreatePointerIndirect(a, b);
4743 SetFS(sel);
4744
4745 return yyrc;
4746}
4747
4748inline BOOL APIENTRY WinDestroyPointer(HPOINTER a)
4749{
4750 BOOL yyrc;
4751 USHORT sel = GetFS();
4752
4753 yyrc = WinDestroyPointer(a);
4754 SetFS(sel);
4755
4756 return yyrc;
4757}
4758
4759inline BOOL APIENTRY WinDrawPointer(HPS a, LONG b, LONG c, HPOINTER d, ULONG e)
4760{
4761 BOOL yyrc;
4762 USHORT sel = GetFS();
4763
4764 yyrc = WinDrawPointer(a, b, c, d, e);
4765 SetFS(sel);
4766
4767 return yyrc;
4768}
4769
4770inline HBITMAP APIENTRY WinGetSysBitmap(HWND a, ULONG b)
4771{
4772 HBITMAP yyrc;
4773 USHORT sel = GetFS();
4774
4775 yyrc = WinGetSysBitmap(a, b);
4776 SetFS(sel);
4777
4778 return yyrc;
4779}
4780
4781inline HPOINTER APIENTRY WinLoadPointer(HWND a, HMODULE b, ULONG c)
4782{
4783 HPOINTER yyrc;
4784 USHORT sel = GetFS();
4785
4786 yyrc = WinLoadPointer(a, b, c);
4787 SetFS(sel);
4788
4789 return yyrc;
4790}
4791
4792inline BOOL APIENTRY WinLockPointerUpdate(HWND a, HPOINTER b, ULONG c)
4793{
4794 BOOL yyrc;
4795 USHORT sel = GetFS();
4796
4797 yyrc = WinLockPointerUpdate(a, b, c);
4798 SetFS(sel);
4799
4800 return yyrc;
4801}
4802
4803inline BOOL APIENTRY WinQueryPointerPos(HWND a, PPOINTL b)
4804{
4805 BOOL yyrc;
4806 USHORT sel = GetFS();
4807
4808 yyrc = WinQueryPointerPos(a, b);
4809 SetFS(sel);
4810
4811 return yyrc;
4812}
4813
4814inline BOOL APIENTRY WinQueryPointerInfo(HPOINTER a, PPOINTERINFO b)
4815{
4816 BOOL yyrc;
4817 USHORT sel = GetFS();
4818
4819 yyrc = WinQueryPointerInfo(a, b);
4820 SetFS(sel);
4821
4822 return yyrc;
4823}
4824
4825inline HPOINTER APIENTRY WinQuerySysPointer(HWND a, LONG b, BOOL c)
4826{
4827 HPOINTER yyrc;
4828 USHORT sel = GetFS();
4829
4830 yyrc = WinQuerySysPointer(a, b, c);
4831 SetFS(sel);
4832
4833 return yyrc;
4834}
4835
4836inline BOOL APIENTRY WinQuerySysPointerData(HWND a, ULONG b, PICONINFO c)
4837{
4838 BOOL yyrc;
4839 USHORT sel = GetFS();
4840
4841 yyrc = WinQuerySysPointerData(a, b, c);
4842 SetFS(sel);
4843
4844 return yyrc;
4845}
4846
4847inline BOOL APIENTRY WinSetPointer(HWND a, HPOINTER b)
4848{
4849 BOOL yyrc;
4850 USHORT sel = GetFS();
4851
4852 yyrc = WinSetPointer(a, b);
4853 SetFS(sel);
4854
4855 return yyrc;
4856}
4857
4858inline BOOL APIENTRY WinSetPointerOwner(HPOINTER a, PID b, BOOL c)
4859{
4860 BOOL yyrc;
4861 USHORT sel = GetFS();
4862
4863 yyrc = WinSetPointerOwner(a, b, c);
4864 SetFS(sel);
4865
4866 return yyrc;
4867}
4868
4869inline BOOL APIENTRY WinSetPointerPos(HWND a, LONG b, LONG c)
4870{
4871 BOOL yyrc;
4872 USHORT sel = GetFS();
4873
4874 yyrc = WinSetPointerPos(a, b, c);
4875 SetFS(sel);
4876
4877 return yyrc;
4878}
4879
4880inline BOOL APIENTRY WinSetSysPointerData(HWND a, ULONG b, CONST ICONINFO *c)
4881{
4882 BOOL yyrc;
4883 USHORT sel = GetFS();
4884
4885 yyrc = WinSetSysPointerData(a, b, c);
4886 SetFS(sel);
4887
4888 return yyrc;
4889}
4890
4891inline BOOL APIENTRY WinShowPointer(HWND a, BOOL b)
4892{
4893 BOOL yyrc;
4894 USHORT sel = GetFS();
4895
4896 yyrc = WinShowPointer(a, b);
4897 SetFS(sel);
4898
4899 return yyrc;
4900}
4901
4902#endif
4903#ifdef INCL_WINRECTANGLES
4904inline BOOL APIENTRY WinCopyRect(HAB a, PRECTL b, CONST RECTL *c)
4905{
4906 BOOL yyrc;
4907 USHORT sel = GetFS();
4908
4909 yyrc = WinCopyRect(a, b, c);
4910 SetFS(sel);
4911
4912 return yyrc;
4913}
4914
4915inline BOOL APIENTRY WinEqualRect(HAB a, CONST RECTL *b, CONST RECTL *c)
4916{
4917 BOOL yyrc;
4918 USHORT sel = GetFS();
4919
4920 yyrc = WinEqualRect(a, b, c);
4921 SetFS(sel);
4922
4923 return yyrc;
4924}
4925
4926inline BOOL APIENTRY WinInflateRect(HAB a, PRECTL b, LONG c, LONG d)
4927{
4928 BOOL yyrc;
4929 USHORT sel = GetFS();
4930
4931 yyrc = WinInflateRect(a, b, c, d);
4932 SetFS(sel);
4933
4934 return yyrc;
4935}
4936
4937inline BOOL APIENTRY WinIntersectRect(HAB a, PRECTL b, CONST RECTL *c, CONST RECTL *d)
4938{
4939 BOOL yyrc;
4940 USHORT sel = GetFS();
4941
4942 yyrc = WinIntersectRect(a, b, c, d);
4943 SetFS(sel);
4944
4945 return yyrc;
4946}
4947
4948inline BOOL APIENTRY WinIsRectEmpty(HAB a, CONST RECTL *b)
4949{
4950 BOOL yyrc;
4951 USHORT sel = GetFS();
4952
4953 yyrc = WinIsRectEmpty(a, b);
4954 SetFS(sel);
4955
4956 return yyrc;
4957}
4958
4959inline BOOL APIENTRY WinMakePoints(HAB a, PPOINTL b, ULONG c)
4960{
4961 BOOL yyrc;
4962 USHORT sel = GetFS();
4963
4964 yyrc = WinMakePoints(a, b, c);
4965 SetFS(sel);
4966
4967 return yyrc;
4968}
4969
4970inline BOOL APIENTRY WinMakeRect(HAB a, PRECTL b)
4971{
4972 BOOL yyrc;
4973 USHORT sel = GetFS();
4974
4975 yyrc = WinMakeRect(a, b);
4976 SetFS(sel);
4977
4978 return yyrc;
4979}
4980
4981inline BOOL APIENTRY WinOffsetRect(HAB a, PRECTL b, LONG c, LONG d)
4982{
4983 BOOL yyrc;
4984 USHORT sel = GetFS();
4985
4986 yyrc = WinOffsetRect(a, b, c, d);
4987 SetFS(sel);
4988
4989 return yyrc;
4990}
4991
4992inline BOOL APIENTRY WinPtInRect(HAB a, CONST RECTL *b, CONST POINTL *c)
4993{
4994 BOOL yyrc;
4995 USHORT sel = GetFS();
4996
4997 yyrc = WinPtInRect(a, b, c);
4998 SetFS(sel);
4999
5000 return yyrc;
5001}
5002
5003inline BOOL APIENTRY WinSetRect(HAB a, PRECTL b, LONG c, LONG d, LONG e, LONG f)
5004{
5005 BOOL yyrc;
5006 USHORT sel = GetFS();
5007
5008 yyrc = WinSetRect(a, b, c, d, e, f);
5009 SetFS(sel);
5010
5011 return yyrc;
5012}
5013
5014inline BOOL APIENTRY WinSetRectEmpty(HAB a, PRECTL b)
5015{
5016 BOOL yyrc;
5017 USHORT sel = GetFS();
5018
5019 yyrc = WinSetRectEmpty(a, b);
5020 SetFS(sel);
5021
5022 return yyrc;
5023}
5024
5025inline BOOL APIENTRY WinSubtractRect(HAB a, PRECTL b, CONST RECTL *c, CONST RECTL *d)
5026{
5027 BOOL yyrc;
5028 USHORT sel = GetFS();
5029
5030 yyrc = WinSubtractRect(a, b, c, d);
5031 SetFS(sel);
5032
5033 return yyrc;
5034}
5035
5036inline BOOL APIENTRY WinUnionRect(HAB a, PRECTL b, CONST RECTL *c, CONST RECTL *d)
5037{
5038 BOOL yyrc;
5039 USHORT sel = GetFS();
5040
5041 yyrc = WinUnionRect(a, b, c, d);
5042 SetFS(sel);
5043
5044 return yyrc;
5045}
5046
5047#endif
5048#ifdef INCL_WINSYS
5049inline LONG APIENTRY WinQueryControlColors(HWND a, LONG b, ULONG c, ULONG d, PCTLCOLOR e)
5050{
5051 LONG yyrc;
5052 USHORT sel = GetFS();
5053
5054 yyrc = WinQueryControlColors(a, b, c, d, e);
5055 SetFS(sel);
5056
5057 return yyrc;
5058}
5059
5060inline ULONG APIENTRY WinQueryPresParam(HWND a, ULONG b, ULONG c, PULONG d, ULONG e, PVOID f, ULONG g)
5061{
5062 ULONG yyrc;
5063 USHORT sel = GetFS();
5064
5065 yyrc = WinQueryPresParam(a, b, c, d, e, f, g);
5066 SetFS(sel);
5067
5068 return yyrc;
5069}
5070
5071inline LONG APIENTRY WinQuerySysColor(HWND a, LONG b, LONG c)
5072{
5073 LONG yyrc;
5074 USHORT sel = GetFS();
5075
5076 yyrc = WinQuerySysColor(a, b, c);
5077 SetFS(sel);
5078
5079 return yyrc;
5080}
5081
5082inline LONG APIENTRY WinQuerySysValue(HWND a, LONG b)
5083{
5084 LONG yyrc;
5085 USHORT sel = GetFS();
5086
5087 yyrc = WinQuerySysValue(a, b);
5088 SetFS(sel);
5089
5090 return yyrc;
5091}
5092
5093inline BOOL APIENTRY WinRemovePresParam(HWND a, ULONG b)
5094{
5095 BOOL yyrc;
5096 USHORT sel = GetFS();
5097
5098 yyrc = WinRemovePresParam(a, b);
5099 SetFS(sel);
5100
5101 return yyrc;
5102}
5103
5104inline LONG APIENTRY WinSetControlColors(HWND a, LONG b, ULONG c, ULONG d, PCTLCOLOR e)
5105{
5106 LONG yyrc;
5107 USHORT sel = GetFS();
5108
5109 yyrc = WinSetControlColors(a, b, c, d, e);
5110 SetFS(sel);
5111
5112 return yyrc;
5113}
5114
5115inline BOOL APIENTRY WinSetPresParam(HWND a, ULONG b, ULONG c, PVOID d)
5116{
5117 BOOL yyrc;
5118 USHORT sel = GetFS();
5119
5120 yyrc = WinSetPresParam(a, b, c, d);
5121 SetFS(sel);
5122
5123 return yyrc;
5124}
5125
5126inline BOOL APIENTRY WinSetSysColors(HWND a, ULONG b, ULONG c, LONG d, ULONG e, CONST LONG *f)
5127{
5128 BOOL yyrc;
5129 USHORT sel = GetFS();
5130
5131 yyrc = WinSetSysColors(a, b, c, d, e, f);
5132 SetFS(sel);
5133
5134 return yyrc;
5135}
5136
5137inline BOOL APIENTRY WinSetSysValue(HWND a, LONG b, LONG c)
5138{
5139 BOOL yyrc;
5140 USHORT sel = GetFS();
5141
5142 yyrc = WinSetSysValue(a, b, c);
5143 SetFS(sel);
5144
5145 return yyrc;
5146}
5147
5148#endif
5149#ifdef INCL_WINTHUNKAPI
5150inline PFN APIENTRY WinQueryClassThunkProc(PCSZ a)
5151{
5152 PFN yyrc;
5153 USHORT sel = GetFS();
5154
5155 yyrc = WinQueryClassThunkProc(a);
5156 SetFS(sel);
5157
5158 return yyrc;
5159}
5160
5161inline LONG APIENTRY WinQueryWindowModel(HWND a)
5162{
5163 LONG yyrc;
5164 USHORT sel = GetFS();
5165
5166 yyrc = WinQueryWindowModel(a);
5167 SetFS(sel);
5168
5169 return yyrc;
5170}
5171
5172inline PFN APIENTRY WinQueryWindowThunkProc(HWND a)
5173{
5174 PFN yyrc;
5175 USHORT sel = GetFS();
5176
5177 yyrc = WinQueryWindowThunkProc(a);
5178 SetFS(sel);
5179
5180 return yyrc;
5181}
5182
5183inline BOOL APIENTRY WinSetClassThunkProc(PCSZ a, PFN b)
5184{
5185 BOOL yyrc;
5186 USHORT sel = GetFS();
5187
5188 yyrc = WinSetClassThunkProc(a, b);
5189 SetFS(sel);
5190
5191 return yyrc;
5192}
5193
5194inline BOOL APIENTRY WinSetWindowThunkProc(HWND a, PFN b)
5195{
5196 BOOL yyrc;
5197 USHORT sel = GetFS();
5198
5199 yyrc = WinSetWindowThunkProc(a, b);
5200 SetFS(sel);
5201
5202 return yyrc;
5203}
5204
5205#endif
5206#ifdef INCL_WINTIMER
5207inline ULONG APIENTRY WinGetCurrentTime(HAB a)
5208{
5209 ULONG yyrc;
5210 USHORT sel = GetFS();
5211
5212 yyrc = WinGetCurrentTime(a);
5213 SetFS(sel);
5214
5215 return yyrc;
5216}
5217
5218inline ULONG APIENTRY WinStartTimer(HAB a, HWND b, ULONG c, ULONG d)
5219{
5220 ULONG yyrc;
5221 USHORT sel = GetFS();
5222
5223 yyrc = WinStartTimer(a, b, c, d);
5224 SetFS(sel);
5225
5226 return yyrc;
5227}
5228
5229inline BOOL APIENTRY WinStopTimer(HAB a, HWND b, ULONG c)
5230{
5231 BOOL yyrc;
5232 USHORT sel = GetFS();
5233
5234 yyrc = WinStopTimer(a, b, c);
5235 SetFS(sel);
5236
5237 return yyrc;
5238}
5239
5240#endif
5241#ifdef INCL_WINTRACKRECT
5242inline BOOL APIENTRY WinShowTrackRect(HWND a, BOOL b)
5243{
5244 BOOL yyrc;
5245 USHORT sel = GetFS();
5246
5247 yyrc = WinShowTrackRect(a, b);
5248 SetFS(sel);
5249
5250 return yyrc;
5251}
5252
5253inline BOOL APIENTRY WinTrackRect(HWND a, HPS b, PTRACKINFO c)
5254{
5255 BOOL yyrc;
5256 USHORT sel = GetFS();
5257
5258 yyrc = WinTrackRect(a, b, c);
5259 SetFS(sel);
5260
5261 return yyrc;
5262}
5263
5264#endif
5265#endif
5266#ifdef INCL_GPI
5267inline LONG APIENTRY GpiAnimatePalette(HPAL a, ULONG b, ULONG c, ULONG d, CONST ULONG *e)
5268{
5269 LONG yyrc;
5270 USHORT sel = GetFS();
5271
5272 yyrc = GpiAnimatePalette(a, b, c, d, e);
5273 SetFS(sel);
5274
5275 return yyrc;
5276}
5277
5278inline BOOL APIENTRY GpiBeginArea(HPS a, ULONG b)
5279{
5280 BOOL yyrc;
5281 USHORT sel = GetFS();
5282
5283 yyrc = GpiBeginArea(a, b);
5284 SetFS(sel);
5285
5286 return yyrc;
5287}
5288
5289inline BOOL APIENTRY GpiBeginElement(HPS a, LONG b, PCSZ c)
5290{
5291 BOOL yyrc;
5292 USHORT sel = GetFS();
5293
5294 yyrc = GpiBeginElement(a, b, c);
5295 SetFS(sel);
5296
5297 return yyrc;
5298}
5299
5300inline BOOL APIENTRY GpiBeginPath(HPS a, LONG b)
5301{
5302 BOOL yyrc;
5303 USHORT sel = GetFS();
5304
5305 yyrc = GpiBeginPath(a, b);
5306 SetFS(sel);
5307
5308 return yyrc;
5309}
5310
5311inline LONG APIENTRY GpiBox(HPS a, LONG b, CONST POINTL *c, LONG d, LONG e)
5312{
5313 LONG yyrc;
5314 USHORT sel = GetFS();
5315
5316 yyrc = GpiBox(a, b, c, d, e);
5317 SetFS(sel);
5318
5319 return yyrc;
5320}
5321
5322inline LONG APIENTRY GpiCallSegmentMatrix(HPS a, LONG b, LONG c, CONST MATRIXLF *d, LONG e)
5323{
5324 LONG yyrc;
5325 USHORT sel = GetFS();
5326
5327 yyrc = GpiCallSegmentMatrix(a, b, c, d, e);
5328 SetFS(sel);
5329
5330 return yyrc;
5331}
5332
5333inline LONG APIENTRY GpiCharString(HPS a, LONG b, PCH c)
5334{
5335 LONG yyrc;
5336 USHORT sel = GetFS();
5337
5338 yyrc = GpiCharString(a, b, c);
5339 SetFS(sel);
5340
5341 return yyrc;
5342}
5343
5344inline LONG APIENTRY GpiCharStringAt(HPS a, CONST POINTL *b, LONG c, PCH d)
5345{
5346 LONG yyrc;
5347 USHORT sel = GetFS();
5348
5349 yyrc = GpiCharStringAt(a, b, c, d);
5350 SetFS(sel);
5351
5352 return yyrc;
5353}
5354
5355inline LONG APIENTRY GpiCharStringPos(HPS a, CONST RECTL *b, ULONG c, LONG d, PCH e, CONST LONG *f)
5356{
5357 LONG yyrc;
5358 USHORT sel = GetFS();
5359
5360 yyrc = GpiCharStringPos(a, b, c, d, e, f);
5361 SetFS(sel);
5362
5363 return yyrc;
5364}
5365
5366inline LONG APIENTRY GpiCharStringPosAt(HPS a, CONST POINTL *b, CONST RECTL *c, ULONG d, LONG e, PCH f, CONST LONG *g)
5367{
5368 LONG yyrc;
5369 USHORT sel = GetFS();
5370
5371 yyrc = GpiCharStringPosAt(a, b, c, d, e, f, g);
5372 SetFS(sel);
5373
5374 return yyrc;
5375}
5376
5377inline BOOL APIENTRY GpiCloseFigure(HPS a)
5378{
5379 BOOL yyrc;
5380 USHORT sel = GetFS();
5381
5382 yyrc = GpiCloseFigure(a);
5383 SetFS(sel);
5384
5385 return yyrc;
5386}
5387
5388inline LONG APIENTRY GpiCombineRegion(HPS a, HRGN b, HRGN c, HRGN d, LONG e)
5389{
5390 LONG yyrc;
5391 USHORT sel = GetFS();
5392
5393 yyrc = GpiCombineRegion(a, b, c, d, e);
5394 SetFS(sel);
5395
5396 return yyrc;
5397}
5398
5399inline BOOL APIENTRY GpiComment(HPS a, LONG b, CONST BYTE *c)
5400{
5401 BOOL yyrc;
5402 USHORT sel = GetFS();
5403
5404 yyrc = GpiComment(a, b, c);
5405 SetFS(sel);
5406
5407 return yyrc;
5408}
5409
5410inline BOOL APIENTRY GpiConvert(HPS a, LONG b, LONG c, LONG d, PPOINTL e)
5411{
5412 BOOL yyrc;
5413 USHORT sel = GetFS();
5414
5415 yyrc = GpiConvert(a, b, c, d, e);
5416 SetFS(sel);
5417
5418 return yyrc;
5419}
5420
5421inline BOOL APIENTRY GpiConvertWithMatrix(HPS a, LONG b, PPOINTL c, LONG d, CONST MATRIXLF *e)
5422{
5423 BOOL yyrc;
5424 USHORT sel = GetFS();
5425
5426 yyrc = GpiConvertWithMatrix(a, b, c, d, e);
5427 SetFS(sel);
5428
5429 return yyrc;
5430}
5431
5432inline HMF APIENTRY GpiCopyMetaFile(HMF a)
5433{
5434 HMF yyrc;
5435 USHORT sel = GetFS();
5436
5437 yyrc = GpiCopyMetaFile(a);
5438 SetFS(sel);
5439
5440 return yyrc;
5441}
5442
5443inline BOOL APIENTRY GpiCreateLogColorTable(HPS a, ULONG b, LONG c, LONG d, LONG e, CONST LONG *f)
5444{
5445 BOOL yyrc;
5446 USHORT sel = GetFS();
5447
5448 yyrc = GpiCreateLogColorTable(a, b, c, d, e, f);
5449 SetFS(sel);
5450
5451 return yyrc;
5452}
5453
5454inline LONG APIENTRY GpiCreateLogFont(HPS a, CONST STR8 *b, LONG c, CONST FATTRS *d)
5455{
5456 LONG yyrc;
5457 USHORT sel = GetFS();
5458
5459 yyrc = GpiCreateLogFont(a, b, c, d);
5460 SetFS(sel);
5461
5462 return yyrc;
5463}
5464
5465inline HPAL APIENTRY GpiCreatePalette(HAB a, ULONG b, ULONG c, ULONG d, CONST ULONG *e)
5466{
5467 HPAL yyrc;
5468 USHORT sel = GetFS();
5469
5470 yyrc = GpiCreatePalette(a, b, c, d, e);
5471 SetFS(sel);
5472
5473 return yyrc;
5474}
5475
5476inline HRGN APIENTRY GpiCreateRegion(HPS a, LONG b, CONST RECTL *c)
5477{
5478 HRGN yyrc;
5479 USHORT sel = GetFS();
5480
5481 yyrc = GpiCreateRegion(a, b, c);
5482 SetFS(sel);
5483
5484 return yyrc;
5485}
5486
5487inline BOOL APIENTRY GpiDeleteElement(HPS a)
5488{
5489 BOOL yyrc;
5490 USHORT sel = GetFS();
5491
5492 yyrc = GpiDeleteElement(a);
5493 SetFS(sel);
5494
5495 return yyrc;
5496}
5497
5498inline BOOL APIENTRY GpiDeleteElementRange(HPS a, LONG b, LONG c)
5499{
5500 BOOL yyrc;
5501 USHORT sel = GetFS();
5502
5503 yyrc = GpiDeleteElementRange(a, b, c);
5504 SetFS(sel);
5505
5506 return yyrc;
5507}
5508
5509inline BOOL APIENTRY GpiDeleteElementsBetweenLabels(HPS a, LONG b, LONG c)
5510{
5511 BOOL yyrc;
5512 USHORT sel = GetFS();
5513
5514 yyrc = GpiDeleteElementsBetweenLabels(a, b, c);
5515 SetFS(sel);
5516
5517 return yyrc;
5518}
5519
5520inline BOOL APIENTRY GpiDeleteMetaFile(HMF a)
5521{
5522 BOOL yyrc;
5523 USHORT sel = GetFS();
5524
5525 yyrc = GpiDeleteMetaFile(a);
5526 SetFS(sel);
5527
5528 return yyrc;
5529}
5530
5531inline BOOL APIENTRY GpiDeletePalette(HPAL a)
5532{
5533 BOOL yyrc;
5534 USHORT sel = GetFS();
5535
5536 yyrc = GpiDeletePalette(a);
5537 SetFS(sel);
5538
5539 return yyrc;
5540}
5541
5542inline BOOL APIENTRY GpiDeleteSetId(HPS a, LONG b)
5543{
5544 BOOL yyrc;
5545 USHORT sel = GetFS();
5546
5547 yyrc = GpiDeleteSetId(a, b);
5548 SetFS(sel);
5549
5550 return yyrc;
5551}
5552
5553inline BOOL APIENTRY GpiDestroyRegion(HPS a, HRGN b)
5554{
5555 BOOL yyrc;
5556 USHORT sel = GetFS();
5557
5558 yyrc = GpiDestroyRegion(a, b);
5559 SetFS(sel);
5560
5561 return yyrc;
5562}
5563
5564inline LONG APIENTRY GpiElement(HPS a, LONG b, PCSZ c, LONG d, CONST BYTE *e)
5565{
5566 LONG yyrc;
5567 USHORT sel = GetFS();
5568
5569 yyrc = GpiElement(a, b, c, d, e);
5570 SetFS(sel);
5571
5572 return yyrc;
5573}
5574
5575inline LONG APIENTRY GpiEndArea(HPS a)
5576{
5577 LONG yyrc;
5578 USHORT sel = GetFS();
5579
5580 yyrc = GpiEndArea(a);
5581 SetFS(sel);
5582
5583 return yyrc;
5584}
5585
5586inline BOOL APIENTRY GpiEndElement(HPS a)
5587{
5588 BOOL yyrc;
5589 USHORT sel = GetFS();
5590
5591 yyrc = GpiEndElement(a);
5592 SetFS(sel);
5593
5594 return yyrc;
5595}
5596
5597inline BOOL APIENTRY GpiEndPath(HPS a)
5598{
5599 BOOL yyrc;
5600 USHORT sel = GetFS();
5601
5602 yyrc = GpiEndPath(a);
5603 SetFS(sel);
5604
5605 return yyrc;
5606}
5607
5608inline LONG APIENTRY GpiEqualRegion(HPS a, HRGN b, HRGN c)
5609{
5610 LONG yyrc;
5611 USHORT sel = GetFS();
5612
5613 yyrc = GpiEqualRegion(a, b, c);
5614 SetFS(sel);
5615
5616 return yyrc;
5617}
5618
5619inline LONG APIENTRY GpiExcludeClipRectangle(HPS a, CONST RECTL *b)
5620{
5621 LONG yyrc;
5622 USHORT sel = GetFS();
5623
5624 yyrc = GpiExcludeClipRectangle(a, b);
5625 SetFS(sel);
5626
5627 return yyrc;
5628}
5629
5630inline LONG APIENTRY GpiFillPath(HPS a, LONG b, LONG c)
5631{
5632 LONG yyrc;
5633 USHORT sel = GetFS();
5634
5635 yyrc = GpiFillPath(a, b, c);
5636 SetFS(sel);
5637
5638 return yyrc;
5639}
5640
5641inline LONG APIENTRY GpiFrameRegion(HPS a, HRGN b, CONST SIZEL *c)
5642{
5643 LONG yyrc;
5644 USHORT sel = GetFS();
5645
5646 yyrc = GpiFrameRegion(a, b, c);
5647 SetFS(sel);
5648
5649 return yyrc;
5650}
5651
5652inline LONG APIENTRY GpiFullArc(HPS a, LONG b, FIXED c)
5653{
5654 LONG yyrc;
5655 USHORT sel = GetFS();
5656
5657 yyrc = GpiFullArc(a, b, c);
5658 SetFS(sel);
5659
5660 return yyrc;
5661}
5662
5663inline LONG APIENTRY GpiImage(HPS a, LONG b, CONST SIZEL *c, LONG d, CONST BYTE *e)
5664{
5665 LONG yyrc;
5666 USHORT sel = GetFS();
5667
5668 yyrc = GpiImage(a, b, c, d, e);
5669 SetFS(sel);
5670
5671 return yyrc;
5672}
5673
5674inline LONG APIENTRY GpiIntersectClipRectangle(HPS a, CONST RECTL *b)
5675{
5676 LONG yyrc;
5677 USHORT sel = GetFS();
5678
5679 yyrc = GpiIntersectClipRectangle(a, b);
5680 SetFS(sel);
5681
5682 return yyrc;
5683}
5684
5685inline BOOL APIENTRY GpiLabel(HPS a, LONG b)
5686{
5687 BOOL yyrc;
5688 USHORT sel = GetFS();
5689
5690 yyrc = GpiLabel(a, b);
5691 SetFS(sel);
5692
5693 return yyrc;
5694}
5695
5696inline LONG APIENTRY GpiLine(HPS a, CONST POINTL *b)
5697{
5698 LONG yyrc;
5699 USHORT sel = GetFS();
5700
5701 yyrc = GpiLine(a, b);
5702 SetFS(sel);
5703
5704 return yyrc;
5705}
5706
5707inline BOOL APIENTRY GpiLoadFonts(HAB a, PCSZ b)
5708{
5709 BOOL yyrc;
5710 USHORT sel = GetFS();
5711
5712 yyrc = GpiLoadFonts(a, b);
5713 SetFS(sel);
5714
5715 return yyrc;
5716}
5717
5718inline HMF APIENTRY GpiLoadMetaFile(HAB a, PCSZ b)
5719{
5720 HMF yyrc;
5721 USHORT sel = GetFS();
5722
5723 yyrc = GpiLoadMetaFile(a, b);
5724 SetFS(sel);
5725
5726 return yyrc;
5727}
5728
5729inline BOOL APIENTRY GpiLoadPublicFonts(HAB a, PCSZ b)
5730{
5731 BOOL yyrc;
5732 USHORT sel = GetFS();
5733
5734 yyrc = GpiLoadPublicFonts(a, b);
5735 SetFS(sel);
5736
5737 return yyrc;
5738}
5739
5740inline LONG APIENTRY GpiMarker(HPS a, CONST POINTL *b)
5741{
5742 LONG yyrc;
5743 USHORT sel = GetFS();
5744
5745 yyrc = GpiMarker(a, b);
5746 SetFS(sel);
5747
5748 return yyrc;
5749}
5750
5751inline BOOL APIENTRY GpiModifyPath(HPS a, LONG b, LONG c)
5752{
5753 BOOL yyrc;
5754 USHORT sel = GetFS();
5755
5756 yyrc = GpiModifyPath(a, b, c);
5757 SetFS(sel);
5758
5759 return yyrc;
5760}
5761
5762inline BOOL APIENTRY GpiMove(HPS a, CONST POINTL *b)
5763{
5764 BOOL yyrc;
5765 USHORT sel = GetFS();
5766
5767 yyrc = GpiMove(a, b);
5768 SetFS(sel);
5769
5770 return yyrc;
5771}
5772
5773inline LONG APIENTRY GpiOffsetClipRegion(HPS a, CONST POINTL *b)
5774{
5775 LONG yyrc;
5776 USHORT sel = GetFS();
5777
5778 yyrc = GpiOffsetClipRegion(a, b);
5779 SetFS(sel);
5780
5781 return yyrc;
5782}
5783
5784inline BOOL APIENTRY GpiOffsetElementPointer(HPS a, LONG b)
5785{
5786 BOOL yyrc;
5787 USHORT sel = GetFS();
5788
5789 yyrc = GpiOffsetElementPointer(a, b);
5790 SetFS(sel);
5791
5792 return yyrc;
5793}
5794
5795inline BOOL APIENTRY GpiOffsetRegion(HPS a, HRGN b, CONST POINTL *c)
5796{
5797 BOOL yyrc;
5798 USHORT sel = GetFS();
5799
5800 yyrc = GpiOffsetRegion(a, b, c);
5801 SetFS(sel);
5802
5803 return yyrc;
5804}
5805
5806inline LONG APIENTRY GpiOutlinePath(HPS a, LONG b, LONG c)
5807{
5808 LONG yyrc;
5809 USHORT sel = GetFS();
5810
5811 yyrc = GpiOutlinePath(a, b, c);
5812 SetFS(sel);
5813
5814 return yyrc;
5815}
5816
5817inline LONG APIENTRY GpiPaintRegion(HPS a, HRGN b)
5818{
5819 LONG yyrc;
5820 USHORT sel = GetFS();
5821
5822 yyrc = GpiPaintRegion(a, b);
5823 SetFS(sel);
5824
5825 return yyrc;
5826}
5827
5828inline LONG APIENTRY GpiPartialArc(HPS a, CONST POINTL *b, FIXED c, FIXED d, FIXED e)
5829{
5830 LONG yyrc;
5831 USHORT sel = GetFS();
5832
5833 yyrc = GpiPartialArc(a, b, c, d, e);
5834 SetFS(sel);
5835
5836 return yyrc;
5837}
5838
5839inline HRGN APIENTRY GpiPathToRegion(HPS a, LONG b, LONG c)
5840{
5841 HRGN yyrc;
5842 USHORT sel = GetFS();
5843
5844 yyrc = GpiPathToRegion(a, b, c);
5845 SetFS(sel);
5846
5847 return yyrc;
5848}
5849
5850inline LONG APIENTRY GpiPlayMetaFile(HPS a, HMF b, LONG c, CONST LONG *d, PLONG e, LONG f, PSZ g)
5851{
5852 LONG yyrc;
5853 USHORT sel = GetFS();
5854
5855 yyrc = GpiPlayMetaFile(a, b, c, d, e, f, g);
5856 SetFS(sel);
5857
5858 return yyrc;
5859}
5860
5861inline LONG APIENTRY GpiPointArc(HPS a, CONST POINTL *b)
5862{
5863 LONG yyrc;
5864 USHORT sel = GetFS();
5865
5866 yyrc = GpiPointArc(a, b);
5867 SetFS(sel);
5868
5869 return yyrc;
5870}
5871
5872inline LONG APIENTRY GpiPolyFillet(HPS a, LONG b, CONST POINTL *c)
5873{
5874 LONG yyrc;
5875 USHORT sel = GetFS();
5876
5877 yyrc = GpiPolyFillet(a, b, c);
5878 SetFS(sel);
5879
5880 return yyrc;
5881}
5882
5883inline LONG APIENTRY GpiPolyFilletSharp(HPS a, LONG b, CONST POINTL *c, CONST FIXED *d)
5884{
5885 LONG yyrc;
5886 USHORT sel = GetFS();
5887
5888 yyrc = GpiPolyFilletSharp(a, b, c, d);
5889 SetFS(sel);
5890
5891 return yyrc;
5892}
5893
5894inline LONG APIENTRY GpiPolygons(HPS a, ULONG b, CONST POLYGON *c, ULONG d, ULONG e)
5895{
5896 LONG yyrc;
5897 USHORT sel = GetFS();
5898
5899 yyrc = GpiPolygons(a, b, c, d, e);
5900 SetFS(sel);
5901
5902 return yyrc;
5903}
5904
5905inline LONG APIENTRY GpiPolyLine(HPS a, LONG b, CONST POINTL *c)
5906{
5907 LONG yyrc;
5908 USHORT sel = GetFS();
5909
5910 yyrc = GpiPolyLine(a, b, c);
5911 SetFS(sel);
5912
5913 return yyrc;
5914}
5915
5916inline LONG APIENTRY GpiPolyLineDisjoint(HPS a, LONG b, CONST POINTL *c)
5917{
5918 LONG yyrc;
5919 USHORT sel = GetFS();
5920
5921 yyrc = GpiPolyLineDisjoint(a, b, c);
5922 SetFS(sel);
5923
5924 return yyrc;
5925}
5926
5927inline LONG APIENTRY GpiPolyMarker(HPS a, LONG b, CONST POINTL *c)
5928{
5929 LONG yyrc;
5930 USHORT sel = GetFS();
5931
5932 yyrc = GpiPolyMarker(a, b, c);
5933 SetFS(sel);
5934
5935 return yyrc;
5936}
5937
5938inline LONG APIENTRY GpiPolySpline(HPS a, LONG b, CONST POINTL *c)
5939{
5940 LONG yyrc;
5941 USHORT sel = GetFS();
5942
5943 yyrc = GpiPolySpline(a, b, c);
5944 SetFS(sel);
5945
5946 return yyrc;
5947}
5948
5949inline BOOL APIENTRY GpiPop(HPS a, LONG b)
5950{
5951 BOOL yyrc;
5952 USHORT sel = GetFS();
5953
5954 yyrc = GpiPop(a, b);
5955 SetFS(sel);
5956
5957 return yyrc;
5958}
5959
5960inline LONG APIENTRY GpiPtInRegion(HPS a, HRGN b, CONST POINTL *c)
5961{
5962 LONG yyrc;
5963 USHORT sel = GetFS();
5964
5965 yyrc = GpiPtInRegion(a, b, c);
5966 SetFS(sel);
5967
5968 return yyrc;
5969}
5970
5971inline LONG APIENTRY GpiPtVisible(HPS a, CONST POINTL *b)
5972{
5973 LONG yyrc;
5974 USHORT sel = GetFS();
5975
5976 yyrc = GpiPtVisible(a, b);
5977 SetFS(sel);
5978
5979 return yyrc;
5980}
5981
5982inline BOOL APIENTRY GpiQueryArcParams(HPS a, PARCPARAMS b)
5983{
5984 BOOL yyrc;
5985 USHORT sel = GetFS();
5986
5987 yyrc = GpiQueryArcParams(a, b);
5988 SetFS(sel);
5989
5990 return yyrc;
5991}
5992
5993inline LONG APIENTRY GpiQueryAttrMode(HPS a)
5994{
5995 LONG yyrc;
5996 USHORT sel = GetFS();
5997
5998 yyrc = GpiQueryAttrMode(a);
5999 SetFS(sel);
6000
6001 return yyrc;
6002}
6003
6004inline LONG APIENTRY GpiQueryAttrs(HPS a, LONG b, ULONG c, PBUNDLE d)
6005{
6006 LONG yyrc;
6007 USHORT sel = GetFS();
6008
6009 yyrc = GpiQueryAttrs(a, b, c, d);
6010 SetFS(sel);
6011
6012 return yyrc;
6013}
6014
6015inline LONG APIENTRY GpiQueryBackColor(HPS a)
6016{
6017 LONG yyrc;
6018 USHORT sel = GetFS();
6019
6020 yyrc = GpiQueryBackColor(a);
6021 SetFS(sel);
6022
6023 return yyrc;
6024}
6025
6026inline LONG APIENTRY GpiQueryBackMix(HPS a)
6027{
6028 LONG yyrc;
6029 USHORT sel = GetFS();
6030
6031 yyrc = GpiQueryBackMix(a);
6032 SetFS(sel);
6033
6034 return yyrc;
6035}
6036
6037inline BOOL APIENTRY GpiQueryCharAngle(HPS a, PGRADIENTL b)
6038{
6039 BOOL yyrc;
6040 USHORT sel = GetFS();
6041
6042 yyrc = GpiQueryCharAngle(a, b);
6043 SetFS(sel);
6044
6045 return yyrc;
6046}
6047
6048inline BOOL APIENTRY GpiQueryCharBox(HPS a, PSIZEF b)
6049{
6050 BOOL yyrc;
6051 USHORT sel = GetFS();
6052
6053 yyrc = GpiQueryCharBox(a, b);
6054 SetFS(sel);
6055
6056 return yyrc;
6057}
6058
6059inline BOOL APIENTRY GpiQueryCharBreakExtra(HPS a, PFIXED b)
6060{
6061 BOOL yyrc;
6062 USHORT sel = GetFS();
6063
6064 yyrc = GpiQueryCharBreakExtra(a, b);
6065 SetFS(sel);
6066
6067 return yyrc;
6068}
6069
6070inline LONG APIENTRY GpiQueryCharDirection(HPS a)
6071{
6072 LONG yyrc;
6073 USHORT sel = GetFS();
6074
6075 yyrc = GpiQueryCharDirection(a);
6076 SetFS(sel);
6077
6078 return yyrc;
6079}
6080
6081inline BOOL APIENTRY GpiQueryCharExtra(HPS a, PFIXED b)
6082{
6083 BOOL yyrc;
6084 USHORT sel = GetFS();
6085
6086 yyrc = GpiQueryCharExtra(a, b);
6087 SetFS(sel);
6088
6089 return yyrc;
6090}
6091
6092inline LONG APIENTRY GpiQueryCharMode(HPS a)
6093{
6094 LONG yyrc;
6095 USHORT sel = GetFS();
6096
6097 yyrc = GpiQueryCharMode(a);
6098 SetFS(sel);
6099
6100 return yyrc;
6101}
6102
6103inline LONG APIENTRY GpiQueryCharSet(HPS a)
6104{
6105 LONG yyrc;
6106 USHORT sel = GetFS();
6107
6108 yyrc = GpiQueryCharSet(a);
6109 SetFS(sel);
6110
6111 return yyrc;
6112}
6113
6114inline BOOL APIENTRY GpiQueryCharShear(HPS a, PPOINTL b)
6115{
6116 BOOL yyrc;
6117 USHORT sel = GetFS();
6118
6119 yyrc = GpiQueryCharShear(a, b);
6120 SetFS(sel);
6121
6122 return yyrc;
6123}
6124
6125inline BOOL APIENTRY GpiQueryCharStringPos(HPS a, ULONG b, LONG c, PCH d, PLONG e, PPOINTL f)
6126{
6127 BOOL yyrc;
6128 USHORT sel = GetFS();
6129
6130 yyrc = GpiQueryCharStringPos(a, b, c, d, e, f);
6131 SetFS(sel);
6132
6133 return yyrc;
6134}
6135
6136inline BOOL APIENTRY GpiQueryCharStringPosAt(HPS a, PPOINTL b, ULONG c, LONG d, PCH e, PLONG f, PPOINTL g)
6137{
6138 BOOL yyrc;
6139 USHORT sel = GetFS();
6140
6141 yyrc = GpiQueryCharStringPosAt(a, b, c, d, e, f, g);
6142 SetFS(sel);
6143
6144 return yyrc;
6145}
6146
6147inline LONG APIENTRY GpiQueryClipBox(HPS a, PRECTL b)
6148{
6149 LONG yyrc;
6150 USHORT sel = GetFS();
6151
6152 yyrc = GpiQueryClipBox(a, b);
6153 SetFS(sel);
6154
6155 return yyrc;
6156}
6157
6158inline HRGN APIENTRY GpiQueryClipRegion(HPS a)
6159{
6160 HRGN yyrc;
6161 USHORT sel = GetFS();
6162
6163 yyrc = GpiQueryClipRegion(a);
6164 SetFS(sel);
6165
6166 return yyrc;
6167}
6168
6169inline LONG APIENTRY GpiQueryColor(HPS a)
6170{
6171 LONG yyrc;
6172 USHORT sel = GetFS();
6173
6174 yyrc = GpiQueryColor(a);
6175 SetFS(sel);
6176
6177 return yyrc;
6178}
6179
6180inline BOOL APIENTRY GpiQueryColorData(HPS a, LONG b, PLONG c)
6181{
6182 BOOL yyrc;
6183 USHORT sel = GetFS();
6184
6185 yyrc = GpiQueryColorData(a, b, c);
6186 SetFS(sel);
6187
6188 return yyrc;
6189}
6190
6191inline LONG APIENTRY GpiQueryColorIndex(HPS a, ULONG b, LONG c)
6192{
6193 LONG yyrc;
6194 USHORT sel = GetFS();
6195
6196 yyrc = GpiQueryColorIndex(a, b, c);
6197 SetFS(sel);
6198
6199 return yyrc;
6200}
6201
6202inline ULONG APIENTRY GpiQueryCp(HPS a)
6203{
6204 ULONG yyrc;
6205 USHORT sel = GetFS();
6206
6207 yyrc = GpiQueryCp(a);
6208 SetFS(sel);
6209
6210 return yyrc;
6211}
6212
6213inline BOOL APIENTRY GpiQueryCurrentPosition(HPS a, PPOINTL b)
6214{
6215 BOOL yyrc;
6216 USHORT sel = GetFS();
6217
6218 yyrc = GpiQueryCurrentPosition(a, b);
6219 SetFS(sel);
6220
6221 return yyrc;
6222}
6223
6224inline BOOL APIENTRY GpiQueryDefArcParams(HPS a, PARCPARAMS b)
6225{
6226 BOOL yyrc;
6227 USHORT sel = GetFS();
6228
6229 yyrc = GpiQueryDefArcParams(a, b);
6230 SetFS(sel);
6231
6232 return yyrc;
6233}
6234
6235inline BOOL APIENTRY GpiQueryDefAttrs(HPS a, LONG b, ULONG c, PBUNDLE d)
6236{
6237 BOOL yyrc;
6238 USHORT sel = GetFS();
6239
6240 yyrc = GpiQueryDefAttrs(a, b, c, d);
6241 SetFS(sel);
6242
6243 return yyrc;
6244}
6245
6246inline BOOL APIENTRY GpiQueryDefCharBox(HPS a, PSIZEL b)
6247{
6248 BOOL yyrc;
6249 USHORT sel = GetFS();
6250
6251 yyrc = GpiQueryDefCharBox(a, b);
6252 SetFS(sel);
6253
6254 return yyrc;
6255}
6256
6257inline BOOL APIENTRY GpiQueryDefTag(HPS a, PLONG b)
6258{
6259 BOOL yyrc;
6260 USHORT sel = GetFS();
6261
6262 yyrc = GpiQueryDefTag(a, b);
6263 SetFS(sel);
6264
6265 return yyrc;
6266}
6267
6268inline BOOL APIENTRY GpiQueryDefViewingLimits(HPS a, PRECTL b)
6269{
6270 BOOL yyrc;
6271 USHORT sel = GetFS();
6272
6273 yyrc = GpiQueryDefViewingLimits(a, b);
6274 SetFS(sel);
6275
6276 return yyrc;
6277}
6278
6279inline BOOL APIENTRY GpiQueryDefaultViewMatrix(HPS a, LONG b, PMATRIXLF c)
6280{
6281 BOOL yyrc;
6282 USHORT sel = GetFS();
6283
6284 yyrc = GpiQueryDefaultViewMatrix(a, b, c);
6285 SetFS(sel);
6286
6287 return yyrc;
6288}
6289
6290inline LONG APIENTRY GpiQueryEditMode(HPS a)
6291{
6292 LONG yyrc;
6293 USHORT sel = GetFS();
6294
6295 yyrc = GpiQueryEditMode(a);
6296 SetFS(sel);
6297
6298 return yyrc;
6299}
6300
6301inline LONG APIENTRY GpiQueryElement(HPS a, LONG b, LONG c, PBYTE d)
6302{
6303 LONG yyrc;
6304 USHORT sel = GetFS();
6305
6306 yyrc = GpiQueryElement(a, b, c, d);
6307 SetFS(sel);
6308
6309 return yyrc;
6310}
6311
6312inline LONG APIENTRY GpiQueryElementPointer(HPS a)
6313{
6314 LONG yyrc;
6315 USHORT sel = GetFS();
6316
6317 yyrc = GpiQueryElementPointer(a);
6318 SetFS(sel);
6319
6320 return yyrc;
6321}
6322
6323inline LONG APIENTRY GpiQueryElementType(HPS a, PLONG b, LONG c, PSZ d)
6324{
6325 LONG yyrc;
6326 USHORT sel = GetFS();
6327
6328 yyrc = GpiQueryElementType(a, b, c, d);
6329 SetFS(sel);
6330
6331 return yyrc;
6332}
6333
6334inline ULONG APIENTRY GpiQueryFaceString(HPS a, PCSZ b, PFACENAMEDESC c, LONG d, PSZ e)
6335{
6336 ULONG yyrc;
6337 USHORT sel = GetFS();
6338
6339 yyrc = GpiQueryFaceString(a, b, c, d, e);
6340 SetFS(sel);
6341
6342 return yyrc;
6343}
6344
6345inline ULONG APIENTRY GpiQueryFontAction(HAB a, ULONG b)
6346{
6347 ULONG yyrc;
6348 USHORT sel = GetFS();
6349
6350 yyrc = GpiQueryFontAction(a, b);
6351 SetFS(sel);
6352
6353 return yyrc;
6354}
6355
6356inline LONG APIENTRY GpiQueryFontFileDescriptions(HAB a, PCSZ b, PLONG c, PFFDESCS d)
6357{
6358 LONG yyrc;
6359 USHORT sel = GetFS();
6360
6361 yyrc = GpiQueryFontFileDescriptions(a, b, c, d);
6362 SetFS(sel);
6363
6364 return yyrc;
6365}
6366
6367inline BOOL APIENTRY GpiQueryFontMetrics(HPS a, LONG b, PFONTMETRICS c)
6368{
6369 BOOL yyrc;
6370 USHORT sel = GetFS();
6371
6372 yyrc = GpiQueryFontMetrics(a, b, c);
6373 SetFS(sel);
6374
6375 return yyrc;
6376}
6377
6378inline LONG APIENTRY GpiQueryFonts(HPS a, ULONG b, PCSZ c, PLONG d, LONG e, PFONTMETRICS f)
6379{
6380 LONG yyrc;
6381 USHORT sel = GetFS();
6382
6383 yyrc = GpiQueryFonts(a, b, c, d, e, f);
6384 SetFS(sel);
6385
6386 return yyrc;
6387}
6388
6389inline LONG APIENTRY GpiQueryFullFontFileDescs(HAB a, PCSZ b, PLONG c, PVOID d, PLONG e)
6390{
6391 LONG yyrc;
6392 USHORT sel = GetFS();
6393
6394 yyrc = GpiQueryFullFontFileDescs(a, b, c, d, e);
6395 SetFS(sel);
6396
6397 return yyrc;
6398}
6399
6400inline BOOL APIENTRY GpiQueryGraphicsField(HPS a, PRECTL b)
6401{
6402 BOOL yyrc;
6403 USHORT sel = GetFS();
6404
6405 yyrc = GpiQueryGraphicsField(a, b);
6406 SetFS(sel);
6407
6408 return yyrc;
6409}
6410
6411inline LONG APIENTRY GpiQueryKerningPairs(HPS a, LONG b, PKERNINGPAIRS c)
6412{
6413 LONG yyrc;
6414 USHORT sel = GetFS();
6415
6416 yyrc = GpiQueryKerningPairs(a, b, c);
6417 SetFS(sel);
6418
6419 return yyrc;
6420}
6421
6422inline LONG APIENTRY GpiQueryLineEnd(HPS a)
6423{
6424 LONG yyrc;
6425 USHORT sel = GetFS();
6426
6427 yyrc = GpiQueryLineEnd(a);
6428 SetFS(sel);
6429
6430 return yyrc;
6431}
6432
6433inline LONG APIENTRY GpiQueryLineJoin(HPS a)
6434{
6435 LONG yyrc;
6436 USHORT sel = GetFS();
6437
6438 yyrc = GpiQueryLineJoin(a);
6439 SetFS(sel);
6440
6441 return yyrc;
6442}
6443
6444inline LONG APIENTRY GpiQueryLineType(HPS a)
6445{
6446 LONG yyrc;
6447 USHORT sel = GetFS();
6448
6449 yyrc = GpiQueryLineType(a);
6450 SetFS(sel);
6451
6452 return yyrc;
6453}
6454
6455inline FIXED APIENTRY GpiQueryLineWidth(HPS a)
6456{
6457 FIXED yyrc;
6458 USHORT sel = GetFS();
6459
6460 yyrc = GpiQueryLineWidth(a);
6461 SetFS(sel);
6462
6463 return yyrc;
6464}
6465
6466inline LONG APIENTRY GpiQueryLineWidthGeom(HPS a)
6467{
6468 LONG yyrc;
6469 USHORT sel = GetFS();
6470
6471 yyrc = GpiQueryLineWidthGeom(a);
6472 SetFS(sel);
6473
6474 return yyrc;
6475}
6476
6477inline LONG APIENTRY GpiQueryLogColorTable(HPS a, ULONG b, LONG c, LONG d, PLONG e)
6478{
6479 LONG yyrc;
6480 USHORT sel = GetFS();
6481
6482 yyrc = GpiQueryLogColorTable(a, b, c, d, e);
6483 SetFS(sel);
6484
6485 return yyrc;
6486}
6487
6488inline BOOL APIENTRY GpiQueryLogicalFont(HPS a, LONG b, PSTR8 c, PFATTRS d, LONG e)
6489{
6490 BOOL yyrc;
6491 USHORT sel = GetFS();
6492
6493 yyrc = GpiQueryLogicalFont(a, b, c, d, e);
6494 SetFS(sel);
6495
6496 return yyrc;
6497}
6498
6499inline LONG APIENTRY GpiQueryMarker(HPS a)
6500{
6501 LONG yyrc;
6502 USHORT sel = GetFS();
6503
6504 yyrc = GpiQueryMarker(a);
6505 SetFS(sel);
6506
6507 return yyrc;
6508}
6509
6510inline BOOL APIENTRY GpiQueryMarkerBox(HPS a, PSIZEF b)
6511{
6512 BOOL yyrc;
6513 USHORT sel = GetFS();
6514
6515 yyrc = GpiQueryMarkerBox(a, b);
6516 SetFS(sel);
6517
6518 return yyrc;
6519}
6520
6521inline LONG APIENTRY GpiQueryMarkerSet(HPS a)
6522{
6523 LONG yyrc;
6524 USHORT sel = GetFS();
6525
6526 yyrc = GpiQueryMarkerSet(a);
6527 SetFS(sel);
6528
6529 return yyrc;
6530}
6531
6532inline BOOL APIENTRY GpiQueryMetaFileBits(HMF a, LONG b, LONG c, PBYTE d)
6533{
6534 BOOL yyrc;
6535 USHORT sel = GetFS();
6536
6537 yyrc = GpiQueryMetaFileBits(a, b, c, d);
6538 SetFS(sel);
6539
6540 return yyrc;
6541}
6542
6543inline LONG APIENTRY GpiQueryMetaFileLength(HMF a)
6544{
6545 LONG yyrc;
6546 USHORT sel = GetFS();
6547
6548 yyrc = GpiQueryMetaFileLength(a);
6549 SetFS(sel);
6550
6551 return yyrc;
6552}
6553
6554inline LONG APIENTRY GpiQueryMix(HPS a)
6555{
6556 LONG yyrc;
6557 USHORT sel = GetFS();
6558
6559 yyrc = GpiQueryMix(a);
6560 SetFS(sel);
6561
6562 return yyrc;
6563}
6564
6565inline BOOL APIENTRY GpiQueryModelTransformMatrix(HPS a, LONG b, PMATRIXLF c)
6566{
6567 BOOL yyrc;
6568 USHORT sel = GetFS();
6569
6570 yyrc = GpiQueryModelTransformMatrix(a, b, c);
6571 SetFS(sel);
6572
6573 return yyrc;
6574}
6575
6576inline LONG APIENTRY GpiQueryNearestColor(HPS a, ULONG b, LONG c)
6577{
6578 LONG yyrc;
6579 USHORT sel = GetFS();
6580
6581 yyrc = GpiQueryNearestColor(a, b, c);
6582 SetFS(sel);
6583
6584 return yyrc;
6585}
6586
6587inline LONG APIENTRY GpiQueryNumberSetIds(HPS a)
6588{
6589 LONG yyrc;
6590 USHORT sel = GetFS();
6591
6592 yyrc = GpiQueryNumberSetIds(a);
6593 SetFS(sel);
6594
6595 return yyrc;
6596}
6597
6598inline BOOL APIENTRY GpiQueryPageViewport(HPS a, PRECTL b)
6599{
6600 BOOL yyrc;
6601 USHORT sel = GetFS();
6602
6603 yyrc = GpiQueryPageViewport(a, b);
6604 SetFS(sel);
6605
6606 return yyrc;
6607}
6608
6609inline HPAL APIENTRY GpiQueryPalette(HPS a)
6610{
6611 HPAL yyrc;
6612 USHORT sel = GetFS();
6613
6614 yyrc = GpiQueryPalette(a);
6615 SetFS(sel);
6616
6617 return yyrc;
6618}
6619
6620inline LONG APIENTRY GpiQueryPaletteInfo(HPAL a, HPS b, ULONG c, ULONG d, ULONG e, PULONG f)
6621{
6622 LONG yyrc;
6623 USHORT sel = GetFS();
6624
6625 yyrc = GpiQueryPaletteInfo(a, b, c, d, e, f);
6626 SetFS(sel);
6627
6628 return yyrc;
6629}
6630
6631inline LONG APIENTRY GpiQueryPattern(HPS a)
6632{
6633 LONG yyrc;
6634 USHORT sel = GetFS();
6635
6636 yyrc = GpiQueryPattern(a);
6637 SetFS(sel);
6638
6639 return yyrc;
6640}
6641
6642inline BOOL APIENTRY GpiQueryPatternRefPoint(HPS a, PPOINTL b)
6643{
6644 BOOL yyrc;
6645 USHORT sel = GetFS();
6646
6647 yyrc = GpiQueryPatternRefPoint(a, b);
6648 SetFS(sel);
6649
6650 return yyrc;
6651}
6652
6653inline LONG APIENTRY GpiQueryPatternSet(HPS a)
6654{
6655 LONG yyrc;
6656 USHORT sel = GetFS();
6657
6658 yyrc = GpiQueryPatternSet(a);
6659 SetFS(sel);
6660
6661 return yyrc;
6662}
6663
6664inline LONG APIENTRY GpiQueryRealColors(HPS a, ULONG b, LONG c, LONG d, PLONG e)
6665{
6666 LONG yyrc;
6667 USHORT sel = GetFS();
6668
6669 yyrc = GpiQueryRealColors(a, b, c, d, e);
6670 SetFS(sel);
6671
6672 return yyrc;
6673}
6674
6675inline LONG APIENTRY GpiQueryRegionBox(HPS a, HRGN b, PRECTL c)
6676{
6677 LONG yyrc;
6678 USHORT sel = GetFS();
6679
6680 yyrc = GpiQueryRegionBox(a, b, c);
6681 SetFS(sel);
6682
6683 return yyrc;
6684}
6685
6686inline BOOL APIENTRY GpiQueryRegionRects(HPS a, HRGN b, PRECTL c, PRGNRECT d, PRECTL e)
6687{
6688 BOOL yyrc;
6689 USHORT sel = GetFS();
6690
6691 yyrc = GpiQueryRegionRects(a, b, c, d, e);
6692 SetFS(sel);
6693
6694 return yyrc;
6695}
6696
6697inline LONG APIENTRY GpiQueryRGBColor(HPS a, ULONG b, LONG c)
6698{
6699 LONG yyrc;
6700 USHORT sel = GetFS();
6701
6702 yyrc = GpiQueryRGBColor(a, b, c);
6703 SetFS(sel);
6704
6705 return yyrc;
6706}
6707
6708inline BOOL APIENTRY GpiQuerySegmentTransformMatrix(HPS a, LONG b, LONG c, PMATRIXLF d)
6709{
6710 BOOL yyrc;
6711 USHORT sel = GetFS();
6712
6713 yyrc = GpiQuerySegmentTransformMatrix(a, b, c, d);
6714 SetFS(sel);
6715
6716 return yyrc;
6717}
6718
6719inline BOOL APIENTRY GpiQuerySetIds(HPS a, LONG b, PLONG c, PSTR8 d, PLONG e)
6720{
6721 BOOL yyrc;
6722 USHORT sel = GetFS();
6723
6724 yyrc = GpiQuerySetIds(a, b, c, d, e);
6725 SetFS(sel);
6726
6727 return yyrc;
6728}
6729
6730inline BOOL APIENTRY GpiQueryTextAlignment(HPS a, PLONG b, PLONG c)
6731{
6732 BOOL yyrc;
6733 USHORT sel = GetFS();
6734
6735 yyrc = GpiQueryTextAlignment(a, b, c);
6736 SetFS(sel);
6737
6738 return yyrc;
6739}
6740
6741inline BOOL APIENTRY GpiQueryTextBox(HPS a, LONG b, PCH c, LONG d, PPOINTL e)
6742{
6743 BOOL yyrc;
6744 USHORT sel = GetFS();
6745
6746 yyrc = GpiQueryTextBox(a, b, c, d, e);
6747 SetFS(sel);
6748
6749 return yyrc;
6750}
6751
6752inline BOOL APIENTRY GpiQueryViewingLimits(HPS a, PRECTL b)
6753{
6754 BOOL yyrc;
6755 USHORT sel = GetFS();
6756
6757 yyrc = GpiQueryViewingLimits(a, b);
6758 SetFS(sel);
6759
6760 return yyrc;
6761}
6762
6763inline BOOL APIENTRY GpiQueryViewingTransformMatrix(HPS a, LONG b, PMATRIXLF c)
6764{
6765 BOOL yyrc;
6766 USHORT sel = GetFS();
6767
6768 yyrc = GpiQueryViewingTransformMatrix(a, b, c);
6769 SetFS(sel);
6770
6771 return yyrc;
6772}
6773
6774inline BOOL APIENTRY GpiQueryWidthTable(HPS a, LONG b, LONG c, PLONG d)
6775{
6776 BOOL yyrc;
6777 USHORT sel = GetFS();
6778
6779 yyrc = GpiQueryWidthTable(a, b, c, d);
6780 SetFS(sel);
6781
6782 return yyrc;
6783}
6784
6785inline LONG APIENTRY GpiRectInRegion(HPS a, HRGN b, CONST RECTL *c)
6786{
6787 LONG yyrc;
6788 USHORT sel = GetFS();
6789
6790 yyrc = GpiRectInRegion(a, b, c);
6791 SetFS(sel);
6792
6793 return yyrc;
6794}
6795
6796inline LONG APIENTRY GpiRectVisible(HPS a, CONST RECTL *b)
6797{
6798 LONG yyrc;
6799 USHORT sel = GetFS();
6800
6801 yyrc = GpiRectVisible(a, b);
6802 SetFS(sel);
6803
6804 return yyrc;
6805}
6806
6807inline BOOL APIENTRY GpiRotate(HPS a, PMATRIXLF b, LONG c, FIXED d, CONST POINTL *e)
6808{
6809 BOOL yyrc;
6810 USHORT sel = GetFS();
6811
6812 yyrc = GpiRotate(a, b, c, d, e);
6813 SetFS(sel);
6814
6815 return yyrc;
6816}
6817
6818inline BOOL APIENTRY GpiSaveMetaFile(HMF a, PCSZ b)
6819{
6820 BOOL yyrc;
6821 USHORT sel = GetFS();
6822
6823 yyrc = GpiSaveMetaFile(a, b);
6824 SetFS(sel);
6825
6826 return yyrc;
6827}
6828
6829inline BOOL APIENTRY GpiScale(HPS a, PMATRIXLF b, LONG c, CONST FIXED *d, CONST POINTL *e)
6830{
6831 BOOL yyrc;
6832 USHORT sel = GetFS();
6833
6834 yyrc = GpiScale(a, b, c, d, e);
6835 SetFS(sel);
6836
6837 return yyrc;
6838}
6839
6840inline HPAL APIENTRY GpiSelectPalette(HPS a, HPAL b)
6841{
6842 HPAL yyrc;
6843 USHORT sel = GetFS();
6844
6845 yyrc = GpiSelectPalette(a, b);
6846 SetFS(sel);
6847
6848 return yyrc;
6849}
6850
6851inline BOOL APIENTRY GpiSetArcParams(HPS a, CONST ARCPARAMS *b)
6852{
6853 BOOL yyrc;
6854 USHORT sel = GetFS();
6855
6856 yyrc = GpiSetArcParams(a, b);
6857 SetFS(sel);
6858
6859 return yyrc;
6860}
6861
6862inline BOOL APIENTRY GpiSetAttrMode(HPS a, LONG b)
6863{
6864 BOOL yyrc;
6865 USHORT sel = GetFS();
6866
6867 yyrc = GpiSetAttrMode(a, b);
6868 SetFS(sel);
6869
6870 return yyrc;
6871}
6872
6873inline BOOL APIENTRY GpiSetAttrs(HPS a, LONG b, ULONG c, ULONG d, CONST VOID *e)
6874{
6875 BOOL yyrc;
6876 USHORT sel = GetFS();
6877
6878 yyrc = GpiSetAttrs(a, b, c, d, e);
6879 SetFS(sel);
6880
6881 return yyrc;
6882}
6883
6884inline BOOL APIENTRY GpiSetBackColor(HPS a, LONG b)
6885{
6886 BOOL yyrc;
6887 USHORT sel = GetFS();
6888
6889 yyrc = GpiSetBackColor(a, b);
6890 SetFS(sel);
6891
6892 return yyrc;
6893}
6894
6895inline BOOL APIENTRY GpiSetBackMix(HPS a, LONG b)
6896{
6897 BOOL yyrc;
6898 USHORT sel = GetFS();
6899
6900 yyrc = GpiSetBackMix(a, b);
6901 SetFS(sel);
6902
6903 return yyrc;
6904}
6905
6906inline BOOL APIENTRY GpiSetCharAngle(HPS a, CONST GRADIENTL *b)
6907{
6908 BOOL yyrc;
6909 USHORT sel = GetFS();
6910
6911 yyrc = GpiSetCharAngle(a, b);
6912 SetFS(sel);
6913
6914 return yyrc;
6915}
6916
6917inline BOOL APIENTRY GpiSetCharBox(HPS a, CONST SIZEF *b)
6918{
6919 BOOL yyrc;
6920 USHORT sel = GetFS();
6921
6922 yyrc = GpiSetCharBox(a, b);
6923 SetFS(sel);
6924
6925 return yyrc;
6926}
6927
6928inline BOOL APIENTRY GpiSetCharBreakExtra(HPS a, FIXED b)
6929{
6930 BOOL yyrc;
6931 USHORT sel = GetFS();
6932
6933 yyrc = GpiSetCharBreakExtra(a, b);
6934 SetFS(sel);
6935
6936 return yyrc;
6937}
6938
6939inline BOOL APIENTRY GpiSetCharDirection(HPS a, LONG b)
6940{
6941 BOOL yyrc;
6942 USHORT sel = GetFS();
6943
6944 yyrc = GpiSetCharDirection(a, b);
6945 SetFS(sel);
6946
6947 return yyrc;
6948}
6949
6950inline BOOL APIENTRY GpiSetCharExtra(HPS a, FIXED b)
6951{
6952 BOOL yyrc;
6953 USHORT sel = GetFS();
6954
6955 yyrc = GpiSetCharExtra(a, b);
6956 SetFS(sel);
6957
6958 return yyrc;
6959}
6960
6961inline BOOL APIENTRY GpiSetCharMode(HPS a, LONG b)
6962{
6963 BOOL yyrc;
6964 USHORT sel = GetFS();
6965
6966 yyrc = GpiSetCharMode(a, b);
6967 SetFS(sel);
6968
6969 return yyrc;
6970}
6971
6972inline BOOL APIENTRY GpiSetCharSet(HPS a, LONG b)
6973{
6974 BOOL yyrc;
6975 USHORT sel = GetFS();
6976
6977 yyrc = GpiSetCharSet(a, b);
6978 SetFS(sel);
6979
6980 return yyrc;
6981}
6982
6983inline BOOL APIENTRY GpiSetCharShear(HPS a, CONST POINTL *b)
6984{
6985 BOOL yyrc;
6986 USHORT sel = GetFS();
6987
6988 yyrc = GpiSetCharShear(a, b);
6989 SetFS(sel);
6990
6991 return yyrc;
6992}
6993
6994inline BOOL APIENTRY GpiSetClipPath(HPS a, LONG b, LONG c)
6995{
6996 BOOL yyrc;
6997 USHORT sel = GetFS();
6998
6999 yyrc = GpiSetClipPath(a, b, c);
7000 SetFS(sel);
7001
7002 return yyrc;
7003}
7004
7005inline LONG APIENTRY GpiSetClipRegion(HPS a, HRGN b, PHRGN c)
7006{
7007 LONG yyrc;
7008 USHORT sel = GetFS();
7009
7010 yyrc = GpiSetClipRegion(a, b, c);
7011 SetFS(sel);
7012
7013 return yyrc;
7014}
7015
7016inline BOOL APIENTRY GpiSetColor(HPS a, LONG b)
7017{
7018 BOOL yyrc;
7019 USHORT sel = GetFS();
7020
7021 yyrc = GpiSetColor(a, b);
7022 SetFS(sel);
7023
7024 return yyrc;
7025}
7026
7027inline BOOL APIENTRY GpiSetCp(HPS a, ULONG b)
7028{
7029 BOOL yyrc;
7030 USHORT sel = GetFS();
7031
7032 yyrc = GpiSetCp(a, b);
7033 SetFS(sel);
7034
7035 return yyrc;
7036}
7037
7038inline BOOL APIENTRY GpiSetCurrentPosition(HPS a, CONST POINTL *b)
7039{
7040 BOOL yyrc;
7041 USHORT sel = GetFS();
7042
7043 yyrc = GpiSetCurrentPosition(a, b);
7044 SetFS(sel);
7045
7046 return yyrc;
7047}
7048
7049inline BOOL APIENTRY GpiSetDefArcParams(HPS a, CONST ARCPARAMS *b)
7050{
7051 BOOL yyrc;
7052 USHORT sel = GetFS();
7053
7054 yyrc = GpiSetDefArcParams(a, b);
7055 SetFS(sel);
7056
7057 return yyrc;
7058}
7059
7060inline BOOL APIENTRY GpiSetDefAttrs(HPS a, LONG b, ULONG c, CONST VOID *d)
7061{
7062 BOOL yyrc;
7063 USHORT sel = GetFS();
7064
7065 yyrc = GpiSetDefAttrs(a, b, c, d);
7066 SetFS(sel);
7067
7068 return yyrc;
7069}
7070
7071inline BOOL APIENTRY GpiSetDefaultViewMatrix(HPS a, LONG b, CONST MATRIXLF *c, LONG d)
7072{
7073 BOOL yyrc;
7074 USHORT sel = GetFS();
7075
7076 yyrc = GpiSetDefaultViewMatrix(a, b, c, d);
7077 SetFS(sel);
7078
7079 return yyrc;
7080}
7081
7082inline BOOL APIENTRY GpiSetDefTag(HPS a, LONG b)
7083{
7084 BOOL yyrc;
7085 USHORT sel = GetFS();
7086
7087 yyrc = GpiSetDefTag(a, b);
7088 SetFS(sel);
7089
7090 return yyrc;
7091}
7092
7093inline BOOL APIENTRY GpiSetDefViewingLimits(HPS a, CONST RECTL *b)
7094{
7095 BOOL yyrc;
7096 USHORT sel = GetFS();
7097
7098 yyrc = GpiSetDefViewingLimits(a, b);
7099 SetFS(sel);
7100
7101 return yyrc;
7102}
7103
7104inline BOOL APIENTRY GpiSetEditMode(HPS a, LONG b)
7105{
7106 BOOL yyrc;
7107 USHORT sel = GetFS();
7108
7109 yyrc = GpiSetEditMode(a, b);
7110 SetFS(sel);
7111
7112 return yyrc;
7113}
7114
7115inline BOOL APIENTRY GpiSetElementPointer(HPS a, LONG b)
7116{
7117 BOOL yyrc;
7118 USHORT sel = GetFS();
7119
7120 yyrc = GpiSetElementPointer(a, b);
7121 SetFS(sel);
7122
7123 return yyrc;
7124}
7125
7126inline BOOL APIENTRY GpiSetElementPointerAtLabel(HPS a, LONG b)
7127{
7128 BOOL yyrc;
7129 USHORT sel = GetFS();
7130
7131 yyrc = GpiSetElementPointerAtLabel(a, b);
7132 SetFS(sel);
7133
7134 return yyrc;
7135}
7136
7137inline BOOL APIENTRY GpiSetGraphicsField(HPS a, CONST RECTL *b)
7138{
7139 BOOL yyrc;
7140 USHORT sel = GetFS();
7141
7142 yyrc = GpiSetGraphicsField(a, b);
7143 SetFS(sel);
7144
7145 return yyrc;
7146}
7147
7148inline BOOL APIENTRY GpiSetLineEnd(HPS a, LONG b)
7149{
7150 BOOL yyrc;
7151 USHORT sel = GetFS();
7152
7153 yyrc = GpiSetLineEnd(a, b);
7154 SetFS(sel);
7155
7156 return yyrc;
7157}
7158
7159inline BOOL APIENTRY GpiSetLineJoin(HPS a, LONG b)
7160{
7161 BOOL yyrc;
7162 USHORT sel = GetFS();
7163
7164 yyrc = GpiSetLineJoin(a, b);
7165 SetFS(sel);
7166
7167 return yyrc;
7168}
7169
7170inline BOOL APIENTRY GpiSetLineType(HPS a, LONG b)
7171{
7172 BOOL yyrc;
7173 USHORT sel = GetFS();
7174
7175 yyrc = GpiSetLineType(a, b);
7176 SetFS(sel);
7177
7178 return yyrc;
7179}
7180
7181inline BOOL APIENTRY GpiSetLineWidth(HPS a, FIXED b)
7182{
7183 BOOL yyrc;
7184 USHORT sel = GetFS();
7185
7186 yyrc = GpiSetLineWidth(a, b);
7187 SetFS(sel);
7188
7189 return yyrc;
7190}
7191
7192inline BOOL APIENTRY GpiSetLineWidthGeom(HPS a, LONG b)
7193{
7194 BOOL yyrc;
7195 USHORT sel = GetFS();
7196
7197 yyrc = GpiSetLineWidthGeom(a, b);
7198 SetFS(sel);
7199
7200 return yyrc;
7201}
7202
7203inline BOOL APIENTRY GpiSetMarker(HPS a, LONG b)
7204{
7205 BOOL yyrc;
7206 USHORT sel = GetFS();
7207
7208 yyrc = GpiSetMarker(a, b);
7209 SetFS(sel);
7210
7211 return yyrc;
7212}
7213
7214inline BOOL APIENTRY GpiSetMarkerBox(HPS a, CONST SIZEF *b)
7215{
7216 BOOL yyrc;
7217 USHORT sel = GetFS();
7218
7219 yyrc = GpiSetMarkerBox(a, b);
7220 SetFS(sel);
7221
7222 return yyrc;
7223}
7224
7225inline BOOL APIENTRY GpiSetMarkerSet(HPS a, LONG b)
7226{
7227 BOOL yyrc;
7228 USHORT sel = GetFS();
7229
7230 yyrc = GpiSetMarkerSet(a, b);
7231 SetFS(sel);
7232
7233 return yyrc;
7234}
7235
7236inline BOOL APIENTRY GpiSetMetaFileBits(HMF a, LONG b, LONG c, CONST BYTE *d)
7237{
7238 BOOL yyrc;
7239 USHORT sel = GetFS();
7240
7241 yyrc = GpiSetMetaFileBits(a, b, c, d);
7242 SetFS(sel);
7243
7244 return yyrc;
7245}
7246
7247inline BOOL APIENTRY GpiSetMix(HPS a, LONG b)
7248{
7249 BOOL yyrc;
7250 USHORT sel = GetFS();
7251
7252 yyrc = GpiSetMix(a, b);
7253 SetFS(sel);
7254
7255 return yyrc;
7256}
7257
7258inline BOOL APIENTRY GpiSetModelTransformMatrix(HPS a, LONG b, CONST MATRIXLF *c, LONG d)
7259{
7260 BOOL yyrc;
7261 USHORT sel = GetFS();
7262
7263 yyrc = GpiSetModelTransformMatrix(a, b, c, d);
7264 SetFS(sel);
7265
7266 return yyrc;
7267}
7268
7269inline BOOL APIENTRY GpiSetPageViewport(HPS a, CONST RECTL *b)
7270{
7271 BOOL yyrc;
7272 USHORT sel = GetFS();
7273
7274 yyrc = GpiSetPageViewport(a, b);
7275 SetFS(sel);
7276
7277 return yyrc;
7278}
7279
7280inline BOOL APIENTRY GpiSetPaletteEntries(HPAL a, ULONG b, ULONG c, ULONG d, CONST ULONG *e)
7281{
7282 BOOL yyrc;
7283 USHORT sel = GetFS();
7284
7285 yyrc = GpiSetPaletteEntries(a, b, c, d, e);
7286 SetFS(sel);
7287
7288 return yyrc;
7289}
7290
7291inline BOOL APIENTRY GpiSetPattern(HPS a, LONG b)
7292{
7293 BOOL yyrc;
7294 USHORT sel = GetFS();
7295
7296 yyrc = GpiSetPattern(a, b);
7297 SetFS(sel);
7298
7299 return yyrc;
7300}
7301
7302inline BOOL APIENTRY GpiSetPatternRefPoint(HPS a, CONST POINTL *b)
7303{
7304 BOOL yyrc;
7305 USHORT sel = GetFS();
7306
7307 yyrc = GpiSetPatternRefPoint(a, b);
7308 SetFS(sel);
7309
7310 return yyrc;
7311}
7312
7313inline BOOL APIENTRY GpiSetPatternSet(HPS a, LONG b)
7314{
7315 BOOL yyrc;
7316 USHORT sel = GetFS();
7317
7318 yyrc = GpiSetPatternSet(a, b);
7319 SetFS(sel);
7320
7321 return yyrc;
7322}
7323
7324inline BOOL APIENTRY GpiSetRegion(HPS a, HRGN b, LONG c, CONST RECTL *d)
7325{
7326 BOOL yyrc;
7327 USHORT sel = GetFS();
7328
7329 yyrc = GpiSetRegion(a, b, c, d);
7330 SetFS(sel);
7331
7332 return yyrc;
7333}
7334
7335inline BOOL APIENTRY GpiSetSegmentTransformMatrix(HPS a, LONG b, LONG c, CONST MATRIXLF *d, LONG e)
7336{
7337 BOOL yyrc;
7338 USHORT sel = GetFS();
7339
7340 yyrc = GpiSetSegmentTransformMatrix(a, b, c, d, e);
7341 SetFS(sel);
7342
7343 return yyrc;
7344}
7345
7346inline BOOL APIENTRY GpiSetTextAlignment(HPS a, LONG b, LONG c)
7347{
7348 BOOL yyrc;
7349 USHORT sel = GetFS();
7350
7351 yyrc = GpiSetTextAlignment(a, b, c);
7352 SetFS(sel);
7353
7354 return yyrc;
7355}
7356
7357inline BOOL APIENTRY GpiSetViewingLimits(HPS a, CONST RECTL *b)
7358{
7359 BOOL yyrc;
7360 USHORT sel = GetFS();
7361
7362 yyrc = GpiSetViewingLimits(a, b);
7363 SetFS(sel);
7364
7365 return yyrc;
7366}
7367
7368inline BOOL APIENTRY GpiSetViewingTransformMatrix(HPS a, LONG b, CONST MATRIXLF *c, LONG d)
7369{
7370 BOOL yyrc;
7371 USHORT sel = GetFS();
7372
7373 yyrc = GpiSetViewingTransformMatrix(a, b, c, d);
7374 SetFS(sel);
7375
7376 return yyrc;
7377}
7378
7379inline LONG APIENTRY GpiStrokePath(HPS a, LONG b, ULONG c)
7380{
7381 LONG yyrc;
7382 USHORT sel = GetFS();
7383
7384 yyrc = GpiStrokePath(a, b, c);
7385 SetFS(sel);
7386
7387 return yyrc;
7388}
7389
7390inline BOOL APIENTRY GpiTranslate(HPS a, PMATRIXLF b, LONG c, CONST POINTL *d)
7391{
7392 BOOL yyrc;
7393 USHORT sel = GetFS();
7394
7395 yyrc = GpiTranslate(a, b, c, d);
7396 SetFS(sel);
7397
7398 return yyrc;
7399}
7400
7401inline BOOL APIENTRY GpiUnloadFonts(HAB a, PCSZ b)
7402{
7403 BOOL yyrc;
7404 USHORT sel = GetFS();
7405
7406 yyrc = GpiUnloadFonts(a, b);
7407 SetFS(sel);
7408
7409 return yyrc;
7410}
7411
7412inline BOOL APIENTRY GpiUnloadPublicFonts(HAB a, PCSZ b)
7413{
7414 BOOL yyrc;
7415 USHORT sel = GetFS();
7416
7417 yyrc = GpiUnloadPublicFonts(a, b);
7418 SetFS(sel);
7419
7420 return yyrc;
7421}
7422
7423#ifdef INCL_GPIBITMAPS
7424inline LONG APIENTRY GpiBitBlt(HPS a, HPS b, LONG c, CONST POINTL *d, LONG e, ULONG f)
7425{
7426 LONG yyrc;
7427 USHORT sel = GetFS();
7428
7429 yyrc = GpiBitBlt(a, b, c, d, e, f);
7430 SetFS(sel);
7431
7432 return yyrc;
7433}
7434
7435inline BOOL APIENTRY GpiDeleteBitmap(HBITMAP a)
7436{
7437 BOOL yyrc;
7438 USHORT sel = GetFS();
7439
7440 yyrc = GpiDeleteBitmap(a);
7441 SetFS(sel);
7442
7443 return yyrc;
7444}
7445
7446inline HBITMAP APIENTRY GpiLoadBitmap(HPS a, HMODULE b, ULONG c, LONG d, LONG e)
7447{
7448 HBITMAP yyrc;
7449 USHORT sel = GetFS();
7450
7451 yyrc = GpiLoadBitmap(a, b, c, d, e);
7452 SetFS(sel);
7453
7454 return yyrc;
7455}
7456
7457inline HBITMAP APIENTRY GpiSetBitmap(HPS a, HBITMAP b)
7458{
7459 HBITMAP yyrc;
7460 USHORT sel = GetFS();
7461
7462 yyrc = GpiSetBitmap(a, b);
7463 SetFS(sel);
7464
7465 return yyrc;
7466}
7467
7468inline LONG APIENTRY GpiWCBitBlt(HPS a, HBITMAP b, LONG c, CONST POINTL *d, LONG e, ULONG f)
7469{
7470 LONG yyrc;
7471 USHORT sel = GetFS();
7472
7473 yyrc = GpiWCBitBlt(a, b, c, d, e, f);
7474 SetFS(sel);
7475
7476 return yyrc;
7477}
7478
7479inline HBITMAP APIENTRY GpiCreateBitmap(HPS a, CONST BITMAPINFOHEADER2 *b, ULONG c, CONST BYTE *d, CONST BITMAPINFO2 *e)
7480{
7481 HBITMAP yyrc;
7482 USHORT sel = GetFS();
7483
7484 yyrc = GpiCreateBitmap(a, b, c, d, e);
7485 SetFS(sel);
7486
7487 return yyrc;
7488}
7489
7490inline LONG APIENTRY GpiDrawBits(HPS a, CONST VOID *b, CONST BITMAPINFO2 *c, LONG d, CONST POINTL *e, LONG f, ULONG g)
7491{
7492 LONG yyrc;
7493 USHORT sel = GetFS();
7494
7495 yyrc = GpiDrawBits(a, b, c, d, e, f, g);
7496 SetFS(sel);
7497
7498 return yyrc;
7499}
7500
7501inline LONG APIENTRY GpiFloodFill(HPS a, LONG b, LONG c)
7502{
7503 LONG yyrc;
7504 USHORT sel = GetFS();
7505
7506 yyrc = GpiFloodFill(a, b, c);
7507 SetFS(sel);
7508
7509 return yyrc;
7510}
7511
7512inline LONG APIENTRY GpiQueryBitmapBits(HPS a, LONG b, LONG c, PBYTE d, PBITMAPINFO2 e)
7513{
7514 LONG yyrc;
7515 USHORT sel = GetFS();
7516
7517 yyrc = GpiQueryBitmapBits(a, b, c, d, e);
7518 SetFS(sel);
7519
7520 return yyrc;
7521}
7522
7523inline BOOL APIENTRY GpiQueryBitmapDimension(HBITMAP a, PSIZEL b)
7524{
7525 BOOL yyrc;
7526 USHORT sel = GetFS();
7527
7528 yyrc = GpiQueryBitmapDimension(a, b);
7529 SetFS(sel);
7530
7531 return yyrc;
7532}
7533
7534inline HBITMAP APIENTRY GpiQueryBitmapHandle(HPS a, LONG b)
7535{
7536 HBITMAP yyrc;
7537 USHORT sel = GetFS();
7538
7539 yyrc = GpiQueryBitmapHandle(a, b);
7540 SetFS(sel);
7541
7542 return yyrc;
7543}
7544
7545inline BOOL APIENTRY GpiQueryBitmapInfoHeader(HBITMAP a, PBITMAPINFOHEADER2 b)
7546{
7547 BOOL yyrc;
7548 USHORT sel = GetFS();
7549
7550 yyrc = GpiQueryBitmapInfoHeader(a, b);
7551 SetFS(sel);
7552
7553 return yyrc;
7554}
7555
7556inline BOOL APIENTRY GpiQueryBitmapParameters(HBITMAP a, PBITMAPINFOHEADER b)
7557{
7558 BOOL yyrc;
7559 USHORT sel = GetFS();
7560
7561 yyrc = GpiQueryBitmapParameters(a, b);
7562 SetFS(sel);
7563
7564 return yyrc;
7565}
7566
7567inline BOOL APIENTRY GpiQueryDeviceBitmapFormats(HPS a, LONG b, PLONG c)
7568{
7569 BOOL yyrc;
7570 USHORT sel = GetFS();
7571
7572 yyrc = GpiQueryDeviceBitmapFormats(a, b, c);
7573 SetFS(sel);
7574
7575 return yyrc;
7576}
7577
7578inline LONG APIENTRY GpiSetBitmapBits(HPS a, LONG b, LONG c, CONST BYTE *d, CONST BITMAPINFO2 *e)
7579{
7580 LONG yyrc;
7581 USHORT sel = GetFS();
7582
7583 yyrc = GpiSetBitmapBits(a, b, c, d, e);
7584 SetFS(sel);
7585
7586 return yyrc;
7587}
7588
7589inline LONG APIENTRY GpiQueryPel(HPS a, PPOINTL b)
7590{
7591 LONG yyrc;
7592 USHORT sel = GetFS();
7593
7594 yyrc = GpiQueryPel(a, b);
7595 SetFS(sel);
7596
7597 return yyrc;
7598}
7599
7600inline BOOL APIENTRY GpiSetBitmapDimension(HBITMAP a, CONST SIZEL *b)
7601{
7602 BOOL yyrc;
7603 USHORT sel = GetFS();
7604
7605 yyrc = GpiSetBitmapDimension(a, b);
7606 SetFS(sel);
7607
7608 return yyrc;
7609}
7610
7611inline BOOL APIENTRY GpiSetBitmapId(HPS a, HBITMAP b, LONG c)
7612{
7613 BOOL yyrc;
7614 USHORT sel = GetFS();
7615
7616 yyrc = GpiSetBitmapId(a, b, c);
7617 SetFS(sel);
7618
7619 return yyrc;
7620}
7621
7622inline LONG APIENTRY GpiSetPel(HPS a, CONST POINTL *b)
7623{
7624 LONG yyrc;
7625 USHORT sel = GetFS();
7626
7627 yyrc = GpiSetPel(a, b);
7628 SetFS(sel);
7629
7630 return yyrc;
7631}
7632
7633#endif
7634#ifdef INCL_GPICONTROL
7635inline BOOL APIENTRY GpiAssociate(HPS a, HDC b)
7636{
7637 BOOL yyrc;
7638 USHORT sel = GetFS();
7639
7640 yyrc = GpiAssociate(a, b);
7641 SetFS(sel);
7642
7643 return yyrc;
7644}
7645
7646inline HPS APIENTRY GpiCreatePS(HAB a, HDC b, PSIZEL c, ULONG d)
7647{
7648 HPS yyrc;
7649 USHORT sel = GetFS();
7650
7651 yyrc = GpiCreatePS(a, b, c, d);
7652 SetFS(sel);
7653
7654 return yyrc;
7655}
7656
7657inline BOOL APIENTRY GpiDestroyPS(HPS a)
7658{
7659 BOOL yyrc;
7660 USHORT sel = GetFS();
7661
7662 yyrc = GpiDestroyPS(a);
7663 SetFS(sel);
7664
7665 return yyrc;
7666}
7667
7668inline BOOL APIENTRY GpiErase(HPS a)
7669{
7670 BOOL yyrc;
7671 USHORT sel = GetFS();
7672
7673 yyrc = GpiErase(a);
7674 SetFS(sel);
7675
7676 return yyrc;
7677}
7678
7679inline HDC APIENTRY GpiQueryDevice(HPS a)
7680{
7681 HDC yyrc;
7682 USHORT sel = GetFS();
7683
7684 yyrc = GpiQueryDevice(a);
7685 SetFS(sel);
7686
7687 return yyrc;
7688}
7689
7690inline BOOL APIENTRY GpiRestorePS(HPS a, LONG b)
7691{
7692 BOOL yyrc;
7693 USHORT sel = GetFS();
7694
7695 yyrc = GpiRestorePS(a, b);
7696 SetFS(sel);
7697
7698 return yyrc;
7699}
7700
7701inline LONG APIENTRY GpiSavePS(HPS a)
7702{
7703 LONG yyrc;
7704 USHORT sel = GetFS();
7705
7706 yyrc = GpiSavePS(a);
7707 SetFS(sel);
7708
7709 return yyrc;
7710}
7711
7712inline LONG APIENTRY GpiErrorSegmentData(HPS a, PLONG b, PLONG c)
7713{
7714 LONG yyrc;
7715 USHORT sel = GetFS();
7716
7717 yyrc = GpiErrorSegmentData(a, b, c);
7718 SetFS(sel);
7719
7720 return yyrc;
7721}
7722
7723inline LONG APIENTRY GpiQueryDrawControl(HPS a, LONG b)
7724{
7725 LONG yyrc;
7726 USHORT sel = GetFS();
7727
7728 yyrc = GpiQueryDrawControl(a, b);
7729 SetFS(sel);
7730
7731 return yyrc;
7732}
7733
7734inline LONG APIENTRY GpiQueryDrawingMode(HPS a)
7735{
7736 LONG yyrc;
7737 USHORT sel = GetFS();
7738
7739 yyrc = GpiQueryDrawingMode(a);
7740 SetFS(sel);
7741
7742 return yyrc;
7743}
7744
7745inline ULONG APIENTRY GpiQueryPS(HPS a, PSIZEL b)
7746{
7747 ULONG yyrc;
7748 USHORT sel = GetFS();
7749
7750 yyrc = GpiQueryPS(a, b);
7751 SetFS(sel);
7752
7753 return yyrc;
7754}
7755
7756inline BOOL APIENTRY GpiResetPS(HPS a, ULONG b)
7757{
7758 BOOL yyrc;
7759 USHORT sel = GetFS();
7760
7761 yyrc = GpiResetPS(a, b);
7762 SetFS(sel);
7763
7764 return yyrc;
7765}
7766
7767inline LONG APIENTRY GpiQueryStopDraw(HPS a)
7768{
7769 LONG yyrc;
7770 USHORT sel = GetFS();
7771
7772 yyrc = GpiQueryStopDraw(a);
7773 SetFS(sel);
7774
7775 return yyrc;
7776}
7777
7778inline BOOL APIENTRY GpiSetDrawControl(HPS a, LONG b, LONG c)
7779{
7780 BOOL yyrc;
7781 USHORT sel = GetFS();
7782
7783 yyrc = GpiSetDrawControl(a, b, c);
7784 SetFS(sel);
7785
7786 return yyrc;
7787}
7788
7789inline BOOL APIENTRY GpiSetDrawingMode(HPS a, LONG b)
7790{
7791 BOOL yyrc;
7792 USHORT sel = GetFS();
7793
7794 yyrc = GpiSetDrawingMode(a, b);
7795 SetFS(sel);
7796
7797 return yyrc;
7798}
7799
7800inline BOOL APIENTRY GpiSetPS(HPS a, CONST SIZEL *b, ULONG c)
7801{
7802 BOOL yyrc;
7803 USHORT sel = GetFS();
7804
7805 yyrc = GpiSetPS(a, b, c);
7806 SetFS(sel);
7807
7808 return yyrc;
7809}
7810
7811inline BOOL APIENTRY GpiSetStopDraw(HPS a, LONG b)
7812{
7813 BOOL yyrc;
7814 USHORT sel = GetFS();
7815
7816 yyrc = GpiSetStopDraw(a, b);
7817 SetFS(sel);
7818
7819 return yyrc;
7820}
7821
7822#endif
7823#ifdef INCL_GPICORRELATION
7824inline LONG APIENTRY GpiCorrelateChain(HPS a, LONG b, CONST POINTL *c, LONG d, LONG e, PLONG f)
7825{
7826 LONG yyrc;
7827 USHORT sel = GetFS();
7828
7829 yyrc = GpiCorrelateChain(a, b, c, d, e, f);
7830 SetFS(sel);
7831
7832 return yyrc;
7833}
7834
7835inline LONG APIENTRY GpiCorrelateFrom(HPS a, LONG b, LONG c, LONG d, CONST POINTL *e, LONG f, LONG g, PLONG h)
7836{
7837 LONG yyrc;
7838 USHORT sel = GetFS();
7839
7840 yyrc = GpiCorrelateFrom(a, b, c, d, e, f, g, h);
7841 SetFS(sel);
7842
7843 return yyrc;
7844}
7845
7846inline LONG APIENTRY GpiCorrelateSegment(HPS a, LONG b, LONG c, CONST POINTL *d, LONG e, LONG f, PLONG g)
7847{
7848 LONG yyrc;
7849 USHORT sel = GetFS();
7850
7851 yyrc = GpiCorrelateSegment(a, b, c, d, e, f, g);
7852 SetFS(sel);
7853
7854 return yyrc;
7855}
7856
7857inline BOOL APIENTRY GpiQueryBoundaryData(HPS a, PRECTL b)
7858{
7859 BOOL yyrc;
7860 USHORT sel = GetFS();
7861
7862 yyrc = GpiQueryBoundaryData(a, b);
7863 SetFS(sel);
7864
7865 return yyrc;
7866}
7867
7868inline BOOL APIENTRY GpiQueryPickAperturePosition(HPS a, PPOINTL b)
7869{
7870 BOOL yyrc;
7871 USHORT sel = GetFS();
7872
7873 yyrc = GpiQueryPickAperturePosition(a, b);
7874 SetFS(sel);
7875
7876 return yyrc;
7877}
7878
7879inline BOOL APIENTRY GpiQueryPickApertureSize(HPS a, PSIZEL b)
7880{
7881 BOOL yyrc;
7882 USHORT sel = GetFS();
7883
7884 yyrc = GpiQueryPickApertureSize(a, b);
7885 SetFS(sel);
7886
7887 return yyrc;
7888}
7889
7890inline BOOL APIENTRY GpiQueryTag(HPS a, PLONG b)
7891{
7892 BOOL yyrc;
7893 USHORT sel = GetFS();
7894
7895 yyrc = GpiQueryTag(a, b);
7896 SetFS(sel);
7897
7898 return yyrc;
7899}
7900
7901inline BOOL APIENTRY GpiResetBoundaryData(HPS a)
7902{
7903 BOOL yyrc;
7904 USHORT sel = GetFS();
7905
7906 yyrc = GpiResetBoundaryData(a);
7907 SetFS(sel);
7908
7909 return yyrc;
7910}
7911
7912inline BOOL APIENTRY GpiSetPickAperturePosition(HPS a, CONST POINTL *b)
7913{
7914 BOOL yyrc;
7915 USHORT sel = GetFS();
7916
7917 yyrc = GpiSetPickAperturePosition(a, b);
7918 SetFS(sel);
7919
7920 return yyrc;
7921}
7922
7923inline BOOL APIENTRY GpiSetPickApertureSize(HPS a, LONG b, CONST SIZEL *c)
7924{
7925 BOOL yyrc;
7926 USHORT sel = GetFS();
7927
7928 yyrc = GpiSetPickApertureSize(a, b, c);
7929 SetFS(sel);
7930
7931 return yyrc;
7932}
7933
7934inline BOOL APIENTRY GpiSetTag(HPS a, LONG b)
7935{
7936 BOOL yyrc;
7937 USHORT sel = GetFS();
7938
7939 yyrc = GpiSetTag(a, b);
7940 SetFS(sel);
7941
7942 return yyrc;
7943}
7944
7945#endif
7946#ifdef INCL_GPIINK
7947inline BOOL APIENTRY GpiBeginInkPath(HPS a, LONG b, ULONG c)
7948{
7949 BOOL yyrc;
7950 USHORT sel = GetFS();
7951
7952 yyrc = GpiBeginInkPath(a, b, c);
7953 SetFS(sel);
7954
7955 return yyrc;
7956}
7957
7958inline BOOL APIENTRY GpiEndInkPath(HPS a, ULONG b)
7959{
7960 BOOL yyrc;
7961 USHORT sel = GetFS();
7962
7963 yyrc = GpiEndInkPath(a, b);
7964 SetFS(sel);
7965
7966 return yyrc;
7967}
7968
7969inline LONG APIENTRY GpiStrokeInkPath(HPS a, LONG b, LONG c, CONST POINTL *d, ULONG e)
7970{
7971 LONG yyrc;
7972 USHORT sel = GetFS();
7973
7974 yyrc = GpiStrokeInkPath(a, b, c, d, e);
7975 SetFS(sel);
7976
7977 return yyrc;
7978}
7979
7980#endif
7981#ifdef INCL_GPISEGMENTS
7982inline BOOL APIENTRY GpiCloseSegment(HPS a)
7983{
7984 BOOL yyrc;
7985 USHORT sel = GetFS();
7986
7987 yyrc = GpiCloseSegment(a);
7988 SetFS(sel);
7989
7990 return yyrc;
7991}
7992
7993inline BOOL APIENTRY GpiDeleteSegment(HPS a, LONG b)
7994{
7995 BOOL yyrc;
7996 USHORT sel = GetFS();
7997
7998 yyrc = GpiDeleteSegment(a, b);
7999 SetFS(sel);
8000
8001 return yyrc;
8002}
8003
8004inline BOOL APIENTRY GpiDeleteSegments(HPS a, LONG b, LONG c)
8005{
8006 BOOL yyrc;
8007 USHORT sel = GetFS();
8008
8009 yyrc = GpiDeleteSegments(a, b, c);
8010 SetFS(sel);
8011
8012 return yyrc;
8013}
8014
8015inline BOOL APIENTRY GpiDrawChain(HPS a)
8016{
8017 BOOL yyrc;
8018 USHORT sel = GetFS();
8019
8020 yyrc = GpiDrawChain(a);
8021 SetFS(sel);
8022
8023 return yyrc;
8024}
8025
8026inline BOOL APIENTRY GpiDrawDynamics(HPS a)
8027{
8028 BOOL yyrc;
8029 USHORT sel = GetFS();
8030
8031 yyrc = GpiDrawDynamics(a);
8032 SetFS(sel);
8033
8034 return yyrc;
8035}
8036
8037inline BOOL APIENTRY GpiDrawFrom(HPS a, LONG b, LONG c)
8038{
8039 BOOL yyrc;
8040 USHORT sel = GetFS();
8041
8042 yyrc = GpiDrawFrom(a, b, c);
8043 SetFS(sel);
8044
8045 return yyrc;
8046}
8047
8048inline BOOL APIENTRY GpiDrawSegment(HPS a, LONG b)
8049{
8050 BOOL yyrc;
8051 USHORT sel = GetFS();
8052
8053 yyrc = GpiDrawSegment(a, b);
8054 SetFS(sel);
8055
8056 return yyrc;
8057}
8058
8059inline LONG APIENTRY GpiGetData(HPS a, LONG b, PLONG c, LONG d, LONG e, PBYTE f)
8060{
8061 LONG yyrc;
8062 USHORT sel = GetFS();
8063
8064 yyrc = GpiGetData(a, b, c, d, e, f);
8065 SetFS(sel);
8066
8067 return yyrc;
8068}
8069
8070inline BOOL APIENTRY GpiOpenSegment(HPS a, LONG b)
8071{
8072 BOOL yyrc;
8073 USHORT sel = GetFS();
8074
8075 yyrc = GpiOpenSegment(a, b);
8076 SetFS(sel);
8077
8078 return yyrc;
8079}
8080
8081inline LONG APIENTRY GpiPutData(HPS a, LONG b, PLONG c, CONST BYTE *d)
8082{
8083 LONG yyrc;
8084 USHORT sel = GetFS();
8085
8086 yyrc = GpiPutData(a, b, c, d);
8087 SetFS(sel);
8088
8089 return yyrc;
8090}
8091
8092inline LONG APIENTRY GpiQueryInitialSegmentAttrs(HPS a, LONG b)
8093{
8094 LONG yyrc;
8095 USHORT sel = GetFS();
8096
8097 yyrc = GpiQueryInitialSegmentAttrs(a, b);
8098 SetFS(sel);
8099
8100 return yyrc;
8101}
8102
8103inline LONG APIENTRY GpiQuerySegmentAttrs(HPS a, LONG b, LONG c)
8104{
8105 LONG yyrc;
8106 USHORT sel = GetFS();
8107
8108 yyrc = GpiQuerySegmentAttrs(a, b, c);
8109 SetFS(sel);
8110
8111 return yyrc;
8112}
8113
8114inline LONG APIENTRY GpiQuerySegmentNames(HPS a, LONG b, LONG c, LONG d, PLONG e)
8115{
8116 LONG yyrc;
8117 USHORT sel = GetFS();
8118
8119 yyrc = GpiQuerySegmentNames(a, b, c, d, e);
8120 SetFS(sel);
8121
8122 return yyrc;
8123}
8124
8125inline LONG APIENTRY GpiQuerySegmentPriority(HPS a, LONG b, LONG c)
8126{
8127 LONG yyrc;
8128 USHORT sel = GetFS();
8129
8130 yyrc = GpiQuerySegmentPriority(a, b, c);
8131 SetFS(sel);
8132
8133 return yyrc;
8134}
8135
8136inline BOOL APIENTRY GpiRemoveDynamics(HPS a, LONG b, LONG c)
8137{
8138 BOOL yyrc;
8139 USHORT sel = GetFS();
8140
8141 yyrc = GpiRemoveDynamics(a, b, c);
8142 SetFS(sel);
8143
8144 return yyrc;
8145}
8146
8147inline BOOL APIENTRY GpiSetInitialSegmentAttrs(HPS a, LONG b, LONG c)
8148{
8149 BOOL yyrc;
8150 USHORT sel = GetFS();
8151
8152 yyrc = GpiSetInitialSegmentAttrs(a, b, c);
8153 SetFS(sel);
8154
8155 return yyrc;
8156}
8157
8158inline BOOL APIENTRY GpiSetSegmentAttrs(HPS a, LONG b, LONG c, LONG d)
8159{
8160 BOOL yyrc;
8161 USHORT sel = GetFS();
8162
8163 yyrc = GpiSetSegmentAttrs(a, b, c, d);
8164 SetFS(sel);
8165
8166 return yyrc;
8167}
8168
8169inline BOOL APIENTRY GpiSetSegmentPriority(HPS a, LONG b, LONG c, LONG d)
8170{
8171 BOOL yyrc;
8172 USHORT sel = GetFS();
8173
8174 yyrc = GpiSetSegmentPriority(a, b, c, d);
8175 SetFS(sel);
8176
8177 return yyrc;
8178}
8179
8180#endif
8181inline HMF APIENTRY DevCloseDC(HDC a)
8182{
8183 HMF yyrc;
8184 USHORT sel = GetFS();
8185
8186 yyrc = DevCloseDC(a);
8187 SetFS(sel);
8188
8189 return yyrc;
8190}
8191
8192inline LONG APIENTRY DevEscape(HDC a, LONG b, LONG c, PBYTE d, PLONG e, PBYTE f)
8193{
8194 LONG yyrc;
8195 USHORT sel = GetFS();
8196
8197 yyrc = DevEscape(a, b, c, d, e, f);
8198 SetFS(sel);
8199
8200 return yyrc;
8201}
8202
8203inline HDC APIENTRY DevOpenDC(HAB a, LONG b, PCSZ c, LONG d, PDEVOPENDATA e, HDC f)
8204{
8205 HDC yyrc;
8206 USHORT sel = GetFS();
8207
8208 yyrc = DevOpenDC(a, b, c, d, e, f);
8209 SetFS(sel);
8210
8211 return yyrc;
8212}
8213
8214inline LONG APIENTRY DevPostDeviceModes(HAB a, PDRIVDATA b, PCSZ c, PCSZ d, PCSZ e, ULONG f)
8215{
8216 LONG yyrc;
8217 USHORT sel = GetFS();
8218
8219 yyrc = DevPostDeviceModes(a, b, c, d, e, f);
8220 SetFS(sel);
8221
8222 return yyrc;
8223}
8224
8225inline BOOL APIENTRY DevQueryCaps(HDC a, LONG b, LONG c, PLONG d)
8226{
8227 BOOL yyrc;
8228 USHORT sel = GetFS();
8229
8230 yyrc = DevQueryCaps(a, b, c, d);
8231 SetFS(sel);
8232
8233 return yyrc;
8234}
8235
8236inline BOOL APIENTRY DevQueryDeviceNames(HAB a, PCSZ b, PLONG c, PSTR32 d, PSTR64 e, PLONG f, PSTR16 g)
8237{
8238 BOOL yyrc;
8239 USHORT sel = GetFS();
8240
8241 yyrc = DevQueryDeviceNames(a, b, c, d, e, f, g);
8242 SetFS(sel);
8243
8244 return yyrc;
8245}
8246
8247inline LONG APIENTRY DevQueryHardcopyCaps(HDC a, LONG b, LONG c, PHCINFO d)
8248{
8249 LONG yyrc;
8250 USHORT sel = GetFS();
8251
8252 yyrc = DevQueryHardcopyCaps(a, b, c, d);
8253 SetFS(sel);
8254
8255 return yyrc;
8256}
8257
8258#endif
8259#ifdef INCL_WINPROGRAMLIST
8260inline HPROGRAM APIENTRY PrfAddProgram(HINI a, PPROGDETAILS b, HPROGRAM c)
8261{
8262 HPROGRAM yyrc;
8263 USHORT sel = GetFS();
8264
8265 yyrc = PrfAddProgram(a, b, c);
8266 SetFS(sel);
8267
8268 return yyrc;
8269}
8270
8271inline BOOL APIENTRY PrfChangeProgram(HINI a, HPROGRAM b, PPROGDETAILS c)
8272{
8273 BOOL yyrc;
8274 USHORT sel = GetFS();
8275
8276 yyrc = PrfChangeProgram(a, b, c);
8277 SetFS(sel);
8278
8279 return yyrc;
8280}
8281
8282inline HPROGRAM APIENTRY PrfCreateGroup(HINI a, PCSZ b, UCHAR c)
8283{
8284 HPROGRAM yyrc;
8285 USHORT sel = GetFS();
8286
8287 yyrc = PrfCreateGroup(a, b, c);
8288 SetFS(sel);
8289
8290 return yyrc;
8291}
8292
8293inline BOOL APIENTRY PrfDestroyGroup(HINI a, HPROGRAM b)
8294{
8295 BOOL yyrc;
8296 USHORT sel = GetFS();
8297
8298 yyrc = PrfDestroyGroup(a, b);
8299 SetFS(sel);
8300
8301 return yyrc;
8302}
8303
8304inline PROGCATEGORY APIENTRY PrfQueryProgramCategory(HINI a, PCSZ b)
8305{
8306 PROGCATEGORY yyrc;
8307 USHORT sel = GetFS();
8308
8309 yyrc = PrfQueryProgramCategory(a, b);
8310 SetFS(sel);
8311
8312 return yyrc;
8313}
8314
8315inline ULONG APIENTRY PrfQueryProgramHandle(HINI a, PCSZ b, PHPROGARRAY c, ULONG d, PULONG e)
8316{
8317 ULONG yyrc;
8318 USHORT sel = GetFS();
8319
8320 yyrc = PrfQueryProgramHandle(a, b, c, d, e);
8321 SetFS(sel);
8322
8323 return yyrc;
8324}
8325
8326inline ULONG APIENTRY PrfQueryProgramTitles(HINI a, HPROGRAM b, PPROGTITLE c, ULONG d, PULONG e)
8327{
8328 ULONG yyrc;
8329 USHORT sel = GetFS();
8330
8331 yyrc = PrfQueryProgramTitles(a, b, c, d, e);
8332 SetFS(sel);
8333
8334 return yyrc;
8335}
8336
8337inline ULONG APIENTRY PrfQueryDefinition(HINI a, HPROGRAM b, PPROGDETAILS c, ULONG d)
8338{
8339 ULONG yyrc;
8340 USHORT sel = GetFS();
8341
8342 yyrc = PrfQueryDefinition(a, b, c, d);
8343 SetFS(sel);
8344
8345 return yyrc;
8346}
8347
8348inline BOOL APIENTRY PrfRemoveProgram(HINI a, HPROGRAM b)
8349{
8350 BOOL yyrc;
8351 USHORT sel = GetFS();
8352
8353 yyrc = PrfRemoveProgram(a, b);
8354 SetFS(sel);
8355
8356 return yyrc;
8357}
8358
8359inline HAPP APIENTRY WinStartApp(HWND a, PPROGDETAILS b, PCSZ c, PVOID d, ULONG e)
8360{
8361 HAPP yyrc;
8362 USHORT sel = GetFS();
8363
8364 yyrc = WinStartApp(a, b, c, d, e);
8365 SetFS(sel);
8366
8367 return yyrc;
8368}
8369
8370inline BOOL APIENTRY WinTerminateApp(HAPP a)
8371{
8372 BOOL yyrc;
8373 USHORT sel = GetFS();
8374
8375 yyrc = WinTerminateApp(a);
8376 SetFS(sel);
8377
8378 return yyrc;
8379}
8380
8381#endif
8382#ifdef INCL_WINSWITCHLIST
8383inline HSWITCH APIENTRY WinAddSwitchEntry(CONST SWCNTRL *a)
8384{
8385 HSWITCH yyrc;
8386 USHORT sel = GetFS();
8387
8388 yyrc = WinAddSwitchEntry(a);
8389 SetFS(sel);
8390
8391 return yyrc;
8392}
8393
8394inline ULONG APIENTRY WinRemoveSwitchEntry(HSWITCH a)
8395{
8396 ULONG yyrc;
8397 USHORT sel = GetFS();
8398
8399 yyrc = WinRemoveSwitchEntry(a);
8400 SetFS(sel);
8401
8402 return yyrc;
8403}
8404
8405inline ULONG APIENTRY WinChangeSwitchEntry(HSWITCH a, CONST SWCNTRL *b)
8406{
8407 ULONG yyrc;
8408 USHORT sel = GetFS();
8409
8410 yyrc = WinChangeSwitchEntry(a, b);
8411 SetFS(sel);
8412
8413 return yyrc;
8414}
8415
8416inline HSWITCH APIENTRY WinCreateSwitchEntry(HAB a, CONST SWCNTRL *b)
8417{
8418 HSWITCH yyrc;
8419 USHORT sel = GetFS();
8420
8421 yyrc = WinCreateSwitchEntry(a, b);
8422 SetFS(sel);
8423
8424 return yyrc;
8425}
8426
8427inline ULONG APIENTRY WinQuerySessionTitle(HAB a, ULONG b, PSZ c, ULONG d)
8428{
8429 ULONG yyrc;
8430 USHORT sel = GetFS();
8431
8432 yyrc = WinQuerySessionTitle(a, b, c, d);
8433 SetFS(sel);
8434
8435 return yyrc;
8436}
8437
8438inline ULONG APIENTRY WinQuerySwitchEntry(HSWITCH a, PSWCNTRL b)
8439{
8440 ULONG yyrc;
8441 USHORT sel = GetFS();
8442
8443 yyrc = WinQuerySwitchEntry(a, b);
8444 SetFS(sel);
8445
8446 return yyrc;
8447}
8448
8449inline HSWITCH APIENTRY WinQuerySwitchHandle(HWND a, PID b)
8450{
8451 HSWITCH yyrc;
8452 USHORT sel = GetFS();
8453
8454 yyrc = WinQuerySwitchHandle(a, b);
8455 SetFS(sel);
8456
8457 return yyrc;
8458}
8459
8460inline ULONG APIENTRY WinQuerySwitchList(HAB a, PSWBLOCK b, ULONG c)
8461{
8462 ULONG yyrc;
8463 USHORT sel = GetFS();
8464
8465 yyrc = WinQuerySwitchList(a, b, c);
8466 SetFS(sel);
8467
8468 return yyrc;
8469}
8470
8471inline ULONG APIENTRY WinQueryTaskSizePos(HAB a, ULONG b, PSWP c)
8472{
8473 ULONG yyrc;
8474 USHORT sel = GetFS();
8475
8476 yyrc = WinQueryTaskSizePos(a, b, c);
8477 SetFS(sel);
8478
8479 return yyrc;
8480}
8481
8482inline ULONG APIENTRY WinQueryTaskTitle(ULONG a, PSZ b, ULONG c)
8483{
8484 ULONG yyrc;
8485 USHORT sel = GetFS();
8486
8487 yyrc = WinQueryTaskTitle(a, b, c);
8488 SetFS(sel);
8489
8490 return yyrc;
8491}
8492
8493inline ULONG APIENTRY WinSwitchToProgram(HSWITCH a)
8494{
8495 ULONG yyrc;
8496 USHORT sel = GetFS();
8497
8498 yyrc = WinSwitchToProgram(a);
8499 SetFS(sel);
8500
8501 return yyrc;
8502}
8503
8504#endif
8505#ifdef INCL_WINSHELLDATA
8506inline BOOL APIENTRY PrfCloseProfile(HINI a)
8507{
8508 BOOL yyrc;
8509 USHORT sel = GetFS();
8510
8511 yyrc = PrfCloseProfile(a);
8512 SetFS(sel);
8513
8514 return yyrc;
8515}
8516
8517inline HINI APIENTRY PrfOpenProfile(HAB a, PCSZ b)
8518{
8519 HINI yyrc;
8520 USHORT sel = GetFS();
8521
8522 yyrc = PrfOpenProfile(a, b);
8523 SetFS(sel);
8524
8525 return yyrc;
8526}
8527
8528inline BOOL APIENTRY PrfQueryProfile(HAB a, PPRFPROFILE b)
8529{
8530 BOOL yyrc;
8531 USHORT sel = GetFS();
8532
8533 yyrc = PrfQueryProfile(a, b);
8534 SetFS(sel);
8535
8536 return yyrc;
8537}
8538
8539inline BOOL APIENTRY PrfQueryProfileData(HINI a, PCSZ b, PCSZ c, PVOID d, PULONG e)
8540{
8541 BOOL yyrc;
8542 USHORT sel = GetFS();
8543
8544 yyrc = PrfQueryProfileData(a, b, c, d, e);
8545 SetFS(sel);
8546
8547 return yyrc;
8548}
8549
8550inline LONG APIENTRY PrfQueryProfileInt(HINI a, PCSZ b, PCSZ c, LONG d)
8551{
8552 LONG yyrc;
8553 USHORT sel = GetFS();
8554
8555 yyrc = PrfQueryProfileInt(a, b, c, d);
8556 SetFS(sel);
8557
8558 return yyrc;
8559}
8560
8561inline BOOL APIENTRY PrfQueryProfileSize(HINI a, PCSZ b, PCSZ c, PULONG d)
8562{
8563 BOOL yyrc;
8564 USHORT sel = GetFS();
8565
8566 yyrc = PrfQueryProfileSize(a, b, c, d);
8567 SetFS(sel);
8568
8569 return yyrc;
8570}
8571
8572inline ULONG APIENTRY PrfQueryProfileString(HINI a, PCSZ b, PCSZ c, PCSZ d, PVOID e, ULONG f)
8573{
8574 ULONG yyrc;
8575 USHORT sel = GetFS();
8576
8577 yyrc = PrfQueryProfileString(a, b, c, d, e, f);
8578 SetFS(sel);
8579
8580 return yyrc;
8581}
8582
8583inline BOOL APIENTRY PrfReset(HAB a, CONST PrfPROFILE *b)
8584{
8585 BOOL yyrc;
8586 USHORT sel = GetFS();
8587
8588 yyrc = PrfReset(a, b);
8589 SetFS(sel);
8590
8591 return yyrc;
8592}
8593
8594inline BOOL APIENTRY PrfWriteProfileData(HINI a, PCSZ b, PCSZ c, PVOID d, ULONG e)
8595{
8596 BOOL yyrc;
8597 USHORT sel = GetFS();
8598
8599 yyrc = PrfWriteProfileData(a, b, c, d, e);
8600 SetFS(sel);
8601
8602 return yyrc;
8603}
8604
8605inline BOOL APIENTRY PrfWriteProfileString(HINI a, PCSZ b, PCSZ c, PCSZ d)
8606{
8607 BOOL yyrc;
8608 USHORT sel = GetFS();
8609
8610 yyrc = PrfWriteProfileString(a, b, c, d);
8611 SetFS(sel);
8612
8613 return yyrc;
8614}
8615
8616#endif
8617#ifdef INCL_WINSTDFILE
8618inline MRESULT APIENTRY WinDefFileDlgProc(HWND a, ULONG b, MPARAM c, MPARAM d)
8619{
8620 MRESULT yyrc;
8621 USHORT sel = GetFS();
8622
8623 yyrc = WinDefFileDlgProc(a, b, c, d);
8624 SetFS(sel);
8625
8626 return yyrc;
8627}
8628
8629inline HWND APIENTRY WinFileDlg(HWND a, HWND b, PFILEDLG c)
8630{
8631 HWND yyrc;
8632 USHORT sel = GetFS();
8633
8634 yyrc = WinFileDlg(a, b, c);
8635 SetFS(sel);
8636
8637 return yyrc;
8638}
8639
8640inline BOOL APIENTRY WinFreeFileDlgList(PAPSZ a)
8641{
8642 BOOL yyrc;
8643 USHORT sel = GetFS();
8644
8645 yyrc = WinFreeFileDlgList(a);
8646 SetFS(sel);
8647
8648 return yyrc;
8649}
8650
8651#endif
8652#ifdef INCL_WINSTDFONT
8653inline HWND APIENTRY WinFontDlg(HWND a, HWND b, PFONTDLG c)
8654{
8655 HWND yyrc;
8656 USHORT sel = GetFS();
8657
8658 yyrc = WinFontDlg(a, b, c);
8659 SetFS(sel);
8660
8661 return yyrc;
8662}
8663
8664inline MRESULT APIENTRY WinDefFontDlgProc(HWND a, ULONG b, MPARAM c, MPARAM d)
8665{
8666 MRESULT yyrc;
8667 USHORT sel = GetFS();
8668
8669 yyrc = WinDefFontDlgProc(a, b, c, d);
8670 SetFS(sel);
8671
8672 return yyrc;
8673}
8674
8675#endif
8676#ifdef INCL_WINSTDDRAG
8677inline BOOL APIENTRY DrgAcceptDroppedFiles(HWND a, PCSZ b, PCSZ c, ULONG d, ULONG e)
8678{
8679 BOOL yyrc;
8680 USHORT sel = GetFS();
8681
8682 yyrc = DrgAcceptDroppedFiles(a, b, c, d, e);
8683 SetFS(sel);
8684
8685 return yyrc;
8686}
8687
8688inline BOOL APIENTRY DrgAccessDraginfo(PDRAGINFO a)
8689{
8690 BOOL yyrc;
8691 USHORT sel = GetFS();
8692
8693 yyrc = DrgAccessDraginfo(a);
8694 SetFS(sel);
8695
8696 return yyrc;
8697}
8698
8699inline HSTR APIENTRY DrgAddStrHandle(PCSZ a)
8700{
8701 HSTR yyrc;
8702 USHORT sel = GetFS();
8703
8704 yyrc = DrgAddStrHandle(a);
8705 SetFS(sel);
8706
8707 return yyrc;
8708}
8709
8710inline PDRAGINFO APIENTRY DrgAllocDraginfo(ULONG a)
8711{
8712 PDRAGINFO yyrc;
8713 USHORT sel = GetFS();
8714
8715 yyrc = DrgAllocDraginfo(a);
8716 SetFS(sel);
8717
8718 return yyrc;
8719}
8720
8721inline PDRAGTRANSFER APIENTRY DrgAllocDragtransfer(ULONG a)
8722{
8723 PDRAGTRANSFER yyrc;
8724 USHORT sel = GetFS();
8725
8726 yyrc = DrgAllocDragtransfer(a);
8727 SetFS(sel);
8728
8729 return yyrc;
8730}
8731
8732inline BOOL APIENTRY DrgCancelLazyDrag()
8733{
8734 BOOL yyrc;
8735 USHORT sel = GetFS();
8736
8737 yyrc = DrgCancelLazyDrag();
8738 SetFS(sel);
8739
8740 return yyrc;
8741}
8742
8743inline BOOL APIENTRY DrgDeleteDraginfoStrHandles(PDRAGINFO a)
8744{
8745 BOOL yyrc;
8746 USHORT sel = GetFS();
8747
8748 yyrc = DrgDeleteDraginfoStrHandles(a);
8749 SetFS(sel);
8750
8751 return yyrc;
8752}
8753
8754inline BOOL APIENTRY DrgDeleteStrHandle(HSTR a)
8755{
8756 BOOL yyrc;
8757 USHORT sel = GetFS();
8758
8759 yyrc = DrgDeleteStrHandle(a);
8760 SetFS(sel);
8761
8762 return yyrc;
8763}
8764
8765inline HWND APIENTRY DrgDrag(HWND a, PDRAGINFO b, PDRAGIMAGE c, ULONG d, LONG e, PVOID f)
8766{
8767 HWND yyrc;
8768 USHORT sel = GetFS();
8769
8770 yyrc = DrgDrag(a, b, c, d, e, f);
8771 SetFS(sel);
8772
8773 return yyrc;
8774}
8775
8776inline BOOL APIENTRY DrgDragFiles(HWND a, PSZ *b, PSZ *c, PSZ *d, ULONG e, HPOINTER f, ULONG g, BOOL h, ULONG i)
8777{
8778 BOOL yyrc;
8779 USHORT sel = GetFS();
8780
8781 yyrc = DrgDragFiles(a, b, c, d, e, f, g, h, i);
8782 SetFS(sel);
8783
8784 return yyrc;
8785}
8786
8787inline BOOL APIENTRY DrgFreeDraginfo(PDRAGINFO a)
8788{
8789 BOOL yyrc;
8790 USHORT sel = GetFS();
8791
8792 yyrc = DrgFreeDraginfo(a);
8793 SetFS(sel);
8794
8795 return yyrc;
8796}
8797
8798inline BOOL APIENTRY DrgFreeDragtransfer(PDRAGTRANSFER a)
8799{
8800 BOOL yyrc;
8801 USHORT sel = GetFS();
8802
8803 yyrc = DrgFreeDragtransfer(a);
8804 SetFS(sel);
8805
8806 return yyrc;
8807}
8808
8809inline HPS APIENTRY DrgGetPS(HWND a)
8810{
8811 HPS yyrc;
8812 USHORT sel = GetFS();
8813
8814 yyrc = DrgGetPS(a);
8815 SetFS(sel);
8816
8817 return yyrc;
8818}
8819
8820inline BOOL APIENTRY DrgLazyDrag(HWND a, PDRAGINFO b, PDRAGIMAGE c, ULONG d, PVOID e)
8821{
8822 BOOL yyrc;
8823 USHORT sel = GetFS();
8824
8825 yyrc = DrgLazyDrag(a, b, c, d, e);
8826 SetFS(sel);
8827
8828 return yyrc;
8829}
8830
8831inline BOOL APIENTRY DrgLazyDrop(HWND a, ULONG b, PPOINTL c)
8832{
8833 BOOL yyrc;
8834 USHORT sel = GetFS();
8835
8836 yyrc = DrgLazyDrop(a, b, c);
8837 SetFS(sel);
8838
8839 return yyrc;
8840}
8841
8842inline BOOL APIENTRY DrgPostTransferMsg(HWND a, ULONG b, PDRAGTRANSFER c, ULONG d, ULONG e, BOOL f)
8843{
8844 BOOL yyrc;
8845 USHORT sel = GetFS();
8846
8847 yyrc = DrgPostTransferMsg(a, b, c, d, e, f);
8848 SetFS(sel);
8849
8850 return yyrc;
8851}
8852
8853inline BOOL APIENTRY DrgPushDraginfo(PDRAGINFO a, HWND b)
8854{
8855 BOOL yyrc;
8856 USHORT sel = GetFS();
8857
8858 yyrc = DrgPushDraginfo(a, b);
8859 SetFS(sel);
8860
8861 return yyrc;
8862}
8863
8864inline PDRAGINFO APIENTRY DrgQueryDraginfoPtr(PDRAGINFO a)
8865{
8866 PDRAGINFO yyrc;
8867 USHORT sel = GetFS();
8868
8869 yyrc = DrgQueryDraginfoPtr(a);
8870 SetFS(sel);
8871
8872 return yyrc;
8873}
8874
8875inline PDRAGINFO APIENTRY DrgQueryDraginfoPtrFromHwnd(HWND a)
8876{
8877 PDRAGINFO yyrc;
8878 USHORT sel = GetFS();
8879
8880 yyrc = DrgQueryDraginfoPtrFromHwnd(a);
8881 SetFS(sel);
8882
8883 return yyrc;
8884}
8885
8886inline PDRAGINFO APIENTRY DrgQueryDraginfoPtrFromDragitem(CONST DRAGITEM *a)
8887{
8888 PDRAGINFO yyrc;
8889 USHORT sel = GetFS();
8890
8891 yyrc = DrgQueryDraginfoPtrFromDragitem(a);
8892 SetFS(sel);
8893
8894 return yyrc;
8895}
8896
8897inline BOOL APIENTRY DrgQueryDragitem(PDRAGINFO a, ULONG b, PDRAGITEM c, ULONG d)
8898{
8899 BOOL yyrc;
8900 USHORT sel = GetFS();
8901
8902 yyrc = DrgQueryDragitem(a, b, c, d);
8903 SetFS(sel);
8904
8905 return yyrc;
8906}
8907
8908inline ULONG APIENTRY DrgQueryDragitemCount(PDRAGINFO a)
8909{
8910 ULONG yyrc;
8911 USHORT sel = GetFS();
8912
8913 yyrc = DrgQueryDragitemCount(a);
8914 SetFS(sel);
8915
8916 return yyrc;
8917}
8918
8919inline PDRAGITEM APIENTRY DrgQueryDragitemPtr(PDRAGINFO a, ULONG b)
8920{
8921 PDRAGITEM yyrc;
8922 USHORT sel = GetFS();
8923
8924 yyrc = DrgQueryDragitemPtr(a, b);
8925 SetFS(sel);
8926
8927 return yyrc;
8928}
8929
8930inline ULONG APIENTRY DrgQueryDragStatus()
8931{
8932 ULONG yyrc;
8933 USHORT sel = GetFS();
8934
8935 yyrc = DrgQueryDragStatus();
8936 SetFS(sel);
8937
8938 return yyrc;
8939}
8940
8941inline BOOL APIENTRY DrgQueryNativeRMF(PDRAGITEM a, ULONG b, PCHAR c)
8942{
8943 BOOL yyrc;
8944 USHORT sel = GetFS();
8945
8946 yyrc = DrgQueryNativeRMF(a, b, c);
8947 SetFS(sel);
8948
8949 return yyrc;
8950}
8951
8952inline ULONG APIENTRY DrgQueryNativeRMFLen(PDRAGITEM a)
8953{
8954 ULONG yyrc;
8955 USHORT sel = GetFS();
8956
8957 yyrc = DrgQueryNativeRMFLen(a);
8958 SetFS(sel);
8959
8960 return yyrc;
8961}
8962
8963inline ULONG APIENTRY DrgQueryStrName(HSTR a, ULONG b, PSZ c)
8964{
8965 ULONG yyrc;
8966 USHORT sel = GetFS();
8967
8968 yyrc = DrgQueryStrName(a, b, c);
8969 SetFS(sel);
8970
8971 return yyrc;
8972}
8973
8974inline ULONG APIENTRY DrgQueryStrNameLen(HSTR a)
8975{
8976 ULONG yyrc;
8977 USHORT sel = GetFS();
8978
8979 yyrc = DrgQueryStrNameLen(a);
8980 SetFS(sel);
8981
8982 return yyrc;
8983}
8984
8985inline BOOL APIENTRY DrgQueryTrueType(PDRAGITEM a, ULONG b, PSZ c)
8986{
8987 BOOL yyrc;
8988 USHORT sel = GetFS();
8989
8990 yyrc = DrgQueryTrueType(a, b, c);
8991 SetFS(sel);
8992
8993 return yyrc;
8994}
8995
8996inline ULONG APIENTRY DrgQueryTrueTypeLen(PDRAGITEM a)
8997{
8998 ULONG yyrc;
8999 USHORT sel = GetFS();
9000
9001 yyrc = DrgQueryTrueTypeLen(a);
9002 SetFS(sel);
9003
9004 return yyrc;
9005}
9006
9007inline PDRAGINFO APIENTRY DrgReallocDraginfo(PDRAGINFO a, ULONG b)
9008{
9009 PDRAGINFO yyrc;
9010 USHORT sel = GetFS();
9011
9012 yyrc = DrgReallocDraginfo(a, b);
9013 SetFS(sel);
9014
9015 return yyrc;
9016}
9017
9018inline BOOL APIENTRY DrgReleasePS(HPS a)
9019{
9020 BOOL yyrc;
9021 USHORT sel = GetFS();
9022
9023 yyrc = DrgReleasePS(a);
9024 SetFS(sel);
9025
9026 return yyrc;
9027}
9028
9029inline MRESULT APIENTRY DrgSendTransferMsg(HWND a, ULONG b, MPARAM c, MPARAM d)
9030{
9031 MRESULT yyrc;
9032 USHORT sel = GetFS();
9033
9034 yyrc = DrgSendTransferMsg(a, b, c, d);
9035 SetFS(sel);
9036
9037 return yyrc;
9038}
9039
9040inline BOOL APIENTRY DrgSetDragImage(PDRAGINFO a, PDRAGIMAGE b, ULONG c, PVOID d)
9041{
9042 BOOL yyrc;
9043 USHORT sel = GetFS();
9044
9045 yyrc = DrgSetDragImage(a, b, c, d);
9046 SetFS(sel);
9047
9048 return yyrc;
9049}
9050
9051inline BOOL APIENTRY DrgSetDragitem(PDRAGINFO a, PDRAGITEM b, ULONG c, ULONG d)
9052{
9053 BOOL yyrc;
9054 USHORT sel = GetFS();
9055
9056 yyrc = DrgSetDragitem(a, b, c, d);
9057 SetFS(sel);
9058
9059 return yyrc;
9060}
9061
9062inline BOOL APIENTRY DrgSetDragPointer(PDRAGINFO a, HPOINTER b)
9063{
9064 BOOL yyrc;
9065 USHORT sel = GetFS();
9066
9067 yyrc = DrgSetDragPointer(a, b);
9068 SetFS(sel);
9069
9070 return yyrc;
9071}
9072
9073inline BOOL APIENTRY DrgVerifyNativeRMF(PDRAGITEM a, PCSZ b)
9074{
9075 BOOL yyrc;
9076 USHORT sel = GetFS();
9077
9078 yyrc = DrgVerifyNativeRMF(a, b);
9079 SetFS(sel);
9080
9081 return yyrc;
9082}
9083
9084inline BOOL APIENTRY DrgVerifyRMF(PDRAGITEM a, PCSZ b, PCSZ c)
9085{
9086 BOOL yyrc;
9087 USHORT sel = GetFS();
9088
9089 yyrc = DrgVerifyRMF(a, b, c);
9090 SetFS(sel);
9091
9092 return yyrc;
9093}
9094
9095inline BOOL APIENTRY DrgVerifyTrueType(PDRAGITEM a, PCSZ b)
9096{
9097 BOOL yyrc;
9098 USHORT sel = GetFS();
9099
9100 yyrc = DrgVerifyTrueType(a, b);
9101 SetFS(sel);
9102
9103 return yyrc;
9104}
9105
9106inline BOOL APIENTRY DrgVerifyType(PDRAGITEM a, PCSZ b)
9107{
9108 BOOL yyrc;
9109 USHORT sel = GetFS();
9110
9111 yyrc = DrgVerifyType(a, b);
9112 SetFS(sel);
9113
9114 return yyrc;
9115}
9116
9117inline BOOL APIENTRY DrgVerifyTypeSet(PDRAGITEM a, PCSZ b, ULONG c, PSZ d)
9118{
9119 BOOL yyrc;
9120 USHORT sel = GetFS();
9121
9122 yyrc = DrgVerifyTypeSet(a, b, c, d);
9123 SetFS(sel);
9124
9125 return yyrc;
9126}
9127
9128#endif
9129#ifdef INCL_WPCLASS
9130inline HOBJECT APIENTRY WinCopyObject(HOBJECT a, HOBJECT b, ULONG c)
9131{
9132 HOBJECT yyrc;
9133 USHORT sel = GetFS();
9134
9135 yyrc = WinCopyObject(a, b, c);
9136 SetFS(sel);
9137
9138 return yyrc;
9139}
9140
9141inline HOBJECT APIENTRY WinCreateObject(PCSZ a, PCSZ b, PCSZ c, PCSZ d, ULONG e)
9142{
9143 HOBJECT yyrc;
9144 USHORT sel = GetFS();
9145
9146 yyrc = WinCreateObject(a, b, c, d, e);
9147 SetFS(sel);
9148
9149 return yyrc;
9150}
9151
9152inline HOBJECT APIENTRY WinCreateShadow(HOBJECT a, HOBJECT b, ULONG c)
9153{
9154 HOBJECT yyrc;
9155 USHORT sel = GetFS();
9156
9157 yyrc = WinCreateShadow(a, b, c);
9158 SetFS(sel);
9159
9160 return yyrc;
9161}
9162
9163inline BOOL APIENTRY WinDeregisterObjectClass(PCSZ a)
9164{
9165 BOOL yyrc;
9166 USHORT sel = GetFS();
9167
9168 yyrc = WinDeregisterObjectClass(a);
9169 SetFS(sel);
9170
9171 return yyrc;
9172}
9173
9174inline BOOL APIENTRY WinDestroyObject(HOBJECT a)
9175{
9176 BOOL yyrc;
9177 USHORT sel = GetFS();
9178
9179 yyrc = WinDestroyObject(a);
9180 SetFS(sel);
9181
9182 return yyrc;
9183}
9184
9185inline BOOL APIENTRY WinEnumObjectClasses(POBJCLASS a, PULONG b)
9186{
9187 BOOL yyrc;
9188 USHORT sel = GetFS();
9189
9190 yyrc = WinEnumObjectClasses(a, b);
9191 SetFS(sel);
9192
9193 return yyrc;
9194}
9195
9196inline BOOL APIENTRY WinIsSOMDDReady()
9197{
9198 BOOL yyrc;
9199 USHORT sel = GetFS();
9200
9201 yyrc = WinIsSOMDDReady();
9202 SetFS(sel);
9203
9204 return yyrc;
9205}
9206
9207inline BOOL APIENTRY WinIsWPDServerReady()
9208{
9209 BOOL yyrc;
9210 USHORT sel = GetFS();
9211
9212 yyrc = WinIsWPDServerReady();
9213 SetFS(sel);
9214
9215 return yyrc;
9216}
9217
9218inline HOBJECT APIENTRY WinMoveObject(HOBJECT a, HOBJECT b, ULONG c)
9219{
9220 HOBJECT yyrc;
9221 USHORT sel = GetFS();
9222
9223 yyrc = WinMoveObject(a, b, c);
9224 SetFS(sel);
9225
9226 return yyrc;
9227}
9228
9229inline BOOL APIENTRY WinOpenObject(HOBJECT a, ULONG b, BOOL c)
9230{
9231 BOOL yyrc;
9232 USHORT sel = GetFS();
9233
9234 yyrc = WinOpenObject(a, b, c);
9235 SetFS(sel);
9236
9237 return yyrc;
9238}
9239
9240inline BOOL APIENTRY WinQueryActiveDesktopPathname(PSZ a, ULONG b)
9241{
9242 BOOL yyrc;
9243 USHORT sel = GetFS();
9244
9245 yyrc = WinQueryActiveDesktopPathname(a, b);
9246 SetFS(sel);
9247
9248 return yyrc;
9249}
9250
9251inline HOBJECT APIENTRY WinQueryObject(PCSZ a)
9252{
9253 HOBJECT yyrc;
9254 USHORT sel = GetFS();
9255
9256 yyrc = WinQueryObject(a);
9257 SetFS(sel);
9258
9259 return yyrc;
9260}
9261
9262inline BOOL APIENTRY WinQueryObjectPath(HOBJECT a, PSZ b, ULONG c)
9263{
9264 BOOL yyrc;
9265 USHORT sel = GetFS();
9266
9267 yyrc = WinQueryObjectPath(a, b, c);
9268 SetFS(sel);
9269
9270 return yyrc;
9271}
9272
9273inline BOOL APIENTRY WinRegisterObjectClass(PCSZ a, PCSZ b)
9274{
9275 BOOL yyrc;
9276 USHORT sel = GetFS();
9277
9278 yyrc = WinRegisterObjectClass(a, b);
9279 SetFS(sel);
9280
9281 return yyrc;
9282}
9283
9284inline BOOL APIENTRY WinReplaceObjectClass(PCSZ a, PCSZ b, BOOL c)
9285{
9286 BOOL yyrc;
9287 USHORT sel = GetFS();
9288
9289 yyrc = WinReplaceObjectClass(a, b, c);
9290 SetFS(sel);
9291
9292 return yyrc;
9293}
9294
9295inline ULONG APIENTRY WinRestartSOMDD(BOOL a)
9296{
9297 ULONG yyrc;
9298 USHORT sel = GetFS();
9299
9300 yyrc = WinRestartSOMDD(a);
9301 SetFS(sel);
9302
9303 return yyrc;
9304}
9305
9306inline ULONG APIENTRY WinRestartWPDServer(BOOL a)
9307{
9308 ULONG yyrc;
9309 USHORT sel = GetFS();
9310
9311 yyrc = WinRestartWPDServer(a);
9312 SetFS(sel);
9313
9314 return yyrc;
9315}
9316
9317inline BOOL APIENTRY WinSaveObject(HOBJECT a, BOOL b)
9318{
9319 BOOL yyrc;
9320 USHORT sel = GetFS();
9321
9322 yyrc = WinSaveObject(a, b);
9323 SetFS(sel);
9324
9325 return yyrc;
9326}
9327
9328inline BOOL APIENTRY WinSetObjectData(HOBJECT a, PCSZ b)
9329{
9330 BOOL yyrc;
9331 USHORT sel = GetFS();
9332
9333 yyrc = WinSetObjectData(a, b);
9334 SetFS(sel);
9335
9336 return yyrc;
9337}
9338
9339inline BOOL APIENTRY WinFreeFileIcon(HPOINTER a)
9340{
9341 BOOL yyrc;
9342 USHORT sel = GetFS();
9343
9344 yyrc = WinFreeFileIcon(a);
9345 SetFS(sel);
9346
9347 return yyrc;
9348}
9349
9350inline HPOINTER APIENTRY WinLoadFileIcon(PCSZ a, BOOL b)
9351{
9352 HPOINTER yyrc;
9353 USHORT sel = GetFS();
9354
9355 yyrc = WinLoadFileIcon(a, b);
9356 SetFS(sel);
9357
9358 return yyrc;
9359}
9360
9361inline BOOL APIENTRY WinRestoreWindowPos(PCSZ a, PCSZ b, HWND c)
9362{
9363 BOOL yyrc;
9364 USHORT sel = GetFS();
9365
9366 yyrc = WinRestoreWindowPos(a, b, c);
9367 SetFS(sel);
9368
9369 return yyrc;
9370}
9371
9372inline BOOL APIENTRY WinSetFileIcon(PCSZ a, CONST ICONINFO *b)
9373{
9374 BOOL yyrc;
9375 USHORT sel = GetFS();
9376
9377 yyrc = WinSetFileIcon(a, b);
9378 SetFS(sel);
9379
9380 return yyrc;
9381}
9382
9383inline BOOL APIENTRY WinShutdownSystem(HAB a, HMQ b)
9384{
9385 BOOL yyrc;
9386 USHORT sel = GetFS();
9387
9388 yyrc = WinShutdownSystem(a, b);
9389 SetFS(sel);
9390
9391 return yyrc;
9392}
9393
9394inline BOOL APIENTRY WinStoreWindowPos(PCSZ a, PCSZ b, HWND c)
9395{
9396 BOOL yyrc;
9397 USHORT sel = GetFS();
9398
9399 yyrc = WinStoreWindowPos(a, b, c);
9400 SetFS(sel);
9401
9402 return yyrc;
9403}
9404
9405#endif
9406#ifdef INCL_SPL
9407inline BOOL APIENTRY SplStdClose(HDC a)
9408{
9409 BOOL yyrc;
9410 USHORT sel = GetFS();
9411
9412 yyrc = SplStdClose(a);
9413 SetFS(sel);
9414
9415 return yyrc;
9416}
9417
9418inline BOOL APIENTRY SplStdDelete(HSTD a)
9419{
9420 BOOL yyrc;
9421 USHORT sel = GetFS();
9422
9423 yyrc = SplStdDelete(a);
9424 SetFS(sel);
9425
9426 return yyrc;
9427}
9428
9429inline BOOL APIENTRY SplStdGetBits(HSTD a, LONG b, LONG c, PCH d)
9430{
9431 BOOL yyrc;
9432 USHORT sel = GetFS();
9433
9434 yyrc = SplStdGetBits(a, b, c, d);
9435 SetFS(sel);
9436
9437 return yyrc;
9438}
9439
9440inline BOOL APIENTRY SplStdOpen(HDC a)
9441{
9442 BOOL yyrc;
9443 USHORT sel = GetFS();
9444
9445 yyrc = SplStdOpen(a);
9446 SetFS(sel);
9447
9448 return yyrc;
9449}
9450
9451inline LONG APIENTRY SplStdQueryLength(HSTD a)
9452{
9453 LONG yyrc;
9454 USHORT sel = GetFS();
9455
9456 yyrc = SplStdQueryLength(a);
9457 SetFS(sel);
9458
9459 return yyrc;
9460}
9461
9462inline BOOL APIENTRY SplStdStart(HDC a)
9463{
9464 BOOL yyrc;
9465 USHORT sel = GetFS();
9466
9467 yyrc = SplStdStart(a);
9468 SetFS(sel);
9469
9470 return yyrc;
9471}
9472
9473inline HSTD APIENTRY SplStdStop(HDC a)
9474{
9475 HSTD yyrc;
9476 USHORT sel = GetFS();
9477
9478 yyrc = SplStdStop(a);
9479 SetFS(sel);
9480
9481 return yyrc;
9482}
9483
9484inline SPLERR APIENTRY SplControlDevice(PSZ a, PSZ b, ULONG c)
9485{
9486 SPLERR yyrc;
9487 USHORT sel = GetFS();
9488
9489 yyrc = SplControlDevice(a, b, c);
9490 SetFS(sel);
9491
9492 return yyrc;
9493}
9494
9495inline SPLERR APIENTRY SplCopyJob(PCSZ a, PCSZ b, ULONG c, PCSZ d, PCSZ e, PULONG f)
9496{
9497 SPLERR yyrc;
9498 USHORT sel = GetFS();
9499
9500 yyrc = SplCopyJob(a, b, c, d, e, f);
9501 SetFS(sel);
9502
9503 return yyrc;
9504}
9505
9506inline SPLERR APIENTRY SplCreateDevice(PSZ a, ULONG b, PVOID c, ULONG d)
9507{
9508 SPLERR yyrc;
9509 USHORT sel = GetFS();
9510
9511 yyrc = SplCreateDevice(a, b, c, d);
9512 SetFS(sel);
9513
9514 return yyrc;
9515}
9516
9517inline SPLERR APIENTRY SplCreatePort(PCSZ a, PCSZ b, PCSZ c, ULONG d, PVOID e, ULONG f)
9518{
9519 SPLERR yyrc;
9520 USHORT sel = GetFS();
9521
9522 yyrc = SplCreatePort(a, b, c, d, e, f);
9523 SetFS(sel);
9524
9525 return yyrc;
9526}
9527
9528inline SPLERR APIENTRY SplCreateQueue(PSZ a, ULONG b, PVOID c, ULONG d)
9529{
9530 SPLERR yyrc;
9531 USHORT sel = GetFS();
9532
9533 yyrc = SplCreateQueue(a, b, c, d);
9534 SetFS(sel);
9535
9536 return yyrc;
9537}
9538
9539inline SPLERR APIENTRY SplDeleteDevice(PSZ a, PSZ b)
9540{
9541 SPLERR yyrc;
9542 USHORT sel = GetFS();
9543
9544 yyrc = SplDeleteDevice(a, b);
9545 SetFS(sel);
9546
9547 return yyrc;
9548}
9549
9550inline SPLERR APIENTRY SplDeleteJob(PSZ a, PSZ b, ULONG c)
9551{
9552 SPLERR yyrc;
9553 USHORT sel = GetFS();
9554
9555 yyrc = SplDeleteJob(a, b, c);
9556 SetFS(sel);
9557
9558 return yyrc;
9559}
9560
9561inline SPLERR APIENTRY SplDeletePort(PCSZ a, PCSZ b)
9562{
9563 SPLERR yyrc;
9564 USHORT sel = GetFS();
9565
9566 yyrc = SplDeletePort(a, b);
9567 SetFS(sel);
9568
9569 return yyrc;
9570}
9571
9572inline SPLERR APIENTRY SplDeleteQueue(PSZ a, PSZ b)
9573{
9574 SPLERR yyrc;
9575 USHORT sel = GetFS();
9576
9577 yyrc = SplDeleteQueue(a, b);
9578 SetFS(sel);
9579
9580 return yyrc;
9581}
9582
9583inline SPLERR APIENTRY SplEnumDevice(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
9584{
9585 SPLERR yyrc;
9586 USHORT sel = GetFS();
9587
9588 yyrc = SplEnumDevice(a, b, c, d, e, f, g, h);
9589 SetFS(sel);
9590
9591 return yyrc;
9592}
9593
9594inline SPLERR APIENTRY SplEnumDriver(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
9595{
9596 SPLERR yyrc;
9597 USHORT sel = GetFS();
9598
9599 yyrc = SplEnumDriver(a, b, c, d, e, f, g, h);
9600 SetFS(sel);
9601
9602 return yyrc;
9603}
9604
9605inline SPLERR APIENTRY SplEnumJob(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, PULONG f, PULONG g, PULONG h, PVOID i)
9606{
9607 SPLERR yyrc;
9608 USHORT sel = GetFS();
9609
9610 yyrc = SplEnumJob(a, b, c, d, e, f, g, h, i);
9611 SetFS(sel);
9612
9613 return yyrc;
9614}
9615
9616inline SPLERR APIENTRY SplEnumPort(PCSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
9617{
9618 SPLERR yyrc;
9619 USHORT sel = GetFS();
9620
9621 yyrc = SplEnumPort(a, b, c, d, e, f, g, h);
9622 SetFS(sel);
9623
9624 return yyrc;
9625}
9626
9627inline SPLERR APIENTRY SplEnumPrinter(PSZ a, ULONG b, ULONG c, PVOID d, ULONG e, PULONG f, PULONG g, PULONG h, PVOID i)
9628{
9629 SPLERR yyrc;
9630 USHORT sel = GetFS();
9631
9632 yyrc = SplEnumPrinter(a, b, c, d, e, f, g, h, i);
9633 SetFS(sel);
9634
9635 return yyrc;
9636}
9637
9638inline SPLERR APIENTRY SplEnumQueue(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
9639{
9640 SPLERR yyrc;
9641 USHORT sel = GetFS();
9642
9643 yyrc = SplEnumQueue(a, b, c, d, e, f, g, h);
9644 SetFS(sel);
9645
9646 return yyrc;
9647}
9648
9649inline SPLERR APIENTRY SplEnumQueueProcessor(PSZ a, ULONG b, PVOID c, ULONG d, PULONG e, PULONG f, PULONG g, PVOID h)
9650{
9651 SPLERR yyrc;
9652 USHORT sel = GetFS();
9653
9654 yyrc = SplEnumQueueProcessor(a, b, c, d, e, f, g, h);
9655 SetFS(sel);
9656
9657 return yyrc;
9658}
9659
9660inline SPLERR APIENTRY SplHoldJob(PCSZ a, PCSZ b, ULONG c)
9661{
9662 SPLERR yyrc;
9663 USHORT sel = GetFS();
9664
9665 yyrc = SplHoldJob(a, b, c);
9666 SetFS(sel);
9667
9668 return yyrc;
9669}
9670
9671inline SPLERR APIENTRY SplHoldQueue(PSZ a, PSZ b)
9672{
9673 SPLERR yyrc;
9674 USHORT sel = GetFS();
9675
9676 yyrc = SplHoldQueue(a, b);
9677 SetFS(sel);
9678
9679 return yyrc;
9680}
9681
9682inline SPLERR APIENTRY SplPurgeQueue(PSZ a, PSZ b)
9683{
9684 SPLERR yyrc;
9685 USHORT sel = GetFS();
9686
9687 yyrc = SplPurgeQueue(a, b);
9688 SetFS(sel);
9689
9690 return yyrc;
9691}
9692
9693inline SPLERR APIENTRY SplQueryDevice(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, PULONG f)
9694{
9695 SPLERR yyrc;
9696 USHORT sel = GetFS();
9697
9698 yyrc = SplQueryDevice(a, b, c, d, e, f);
9699 SetFS(sel);
9700
9701 return yyrc;
9702}
9703
9704inline SPLERR APIENTRY SplQueryDriver(PCSZ a, PCSZ b, PCSZ c, ULONG d, PVOID e, ULONG f, PULONG g)
9705{
9706 SPLERR yyrc;
9707 USHORT sel = GetFS();
9708
9709 yyrc = SplQueryDriver(a, b, c, d, e, f, g);
9710 SetFS(sel);
9711
9712 return yyrc;
9713}
9714
9715inline SPLERR APIENTRY SplQueryJob(PSZ a, PSZ b, ULONG c, ULONG d, PVOID e, ULONG f, PULONG g)
9716{
9717 SPLERR yyrc;
9718 USHORT sel = GetFS();
9719
9720 yyrc = SplQueryJob(a, b, c, d, e, f, g);
9721 SetFS(sel);
9722
9723 return yyrc;
9724}
9725
9726inline SPLERR APIENTRY SplQueryPort(PCSZ a, PCSZ b, ULONG c, PVOID d, ULONG e, PULONG f)
9727{
9728 SPLERR yyrc;
9729 USHORT sel = GetFS();
9730
9731 yyrc = SplQueryPort(a, b, c, d, e, f);
9732 SetFS(sel);
9733
9734 return yyrc;
9735}
9736
9737inline SPLERR APIENTRY SplQueryQueue(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, PULONG f)
9738{
9739 SPLERR yyrc;
9740 USHORT sel = GetFS();
9741
9742 yyrc = SplQueryQueue(a, b, c, d, e, f);
9743 SetFS(sel);
9744
9745 return yyrc;
9746}
9747
9748inline SPLERR APIENTRY SplReleaseJob(PCSZ a, PCSZ b, ULONG c)
9749{
9750 SPLERR yyrc;
9751 USHORT sel = GetFS();
9752
9753 yyrc = SplReleaseJob(a, b, c);
9754 SetFS(sel);
9755
9756 return yyrc;
9757}
9758
9759inline SPLERR APIENTRY SplReleaseQueue(PSZ a, PSZ b)
9760{
9761 SPLERR yyrc;
9762 USHORT sel = GetFS();
9763
9764 yyrc = SplReleaseQueue(a, b);
9765 SetFS(sel);
9766
9767 return yyrc;
9768}
9769
9770inline SPLERR APIENTRY SplSetDevice(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, ULONG f)
9771{
9772 SPLERR yyrc;
9773 USHORT sel = GetFS();
9774
9775 yyrc = SplSetDevice(a, b, c, d, e, f);
9776 SetFS(sel);
9777
9778 return yyrc;
9779}
9780
9781inline SPLERR APIENTRY SplSetDriver(PCSZ a, PCSZ b, PCSZ c, ULONG d, PVOID e, ULONG f, ULONG g)
9782{
9783 SPLERR yyrc;
9784 USHORT sel = GetFS();
9785
9786 yyrc = SplSetDriver(a, b, c, d, e, f, g);
9787 SetFS(sel);
9788
9789 return yyrc;
9790}
9791
9792inline SPLERR APIENTRY SplSetJob(PSZ a, PSZ b, ULONG c, ULONG d, PVOID e, ULONG f, ULONG g)
9793{
9794 SPLERR yyrc;
9795 USHORT sel = GetFS();
9796
9797 yyrc = SplSetJob(a, b, c, d, e, f, g);
9798 SetFS(sel);
9799
9800 return yyrc;
9801}
9802
9803inline SPLERR APIENTRY SplSetPort(PCSZ a, PCSZ b, ULONG c, PVOID d, ULONG e, ULONG f)
9804{
9805 SPLERR yyrc;
9806 USHORT sel = GetFS();
9807
9808 yyrc = SplSetPort(a, b, c, d, e, f);
9809 SetFS(sel);
9810
9811 return yyrc;
9812}
9813
9814inline SPLERR APIENTRY SplSetQueue(PSZ a, PSZ b, ULONG c, PVOID d, ULONG e, ULONG f)
9815{
9816 SPLERR yyrc;
9817 USHORT sel = GetFS();
9818
9819 yyrc = SplSetQueue(a, b, c, d, e, f);
9820 SetFS(sel);
9821
9822 return yyrc;
9823}
9824
9825inline ULONG APIENTRY SplMessageBox(PSZ a, ULONG b, ULONG c, PSZ d, PSZ e, ULONG f, ULONG g)
9826{
9827 ULONG yyrc;
9828 USHORT sel = GetFS();
9829
9830 yyrc = SplMessageBox(a, b, c, d, e, f, g);
9831 SetFS(sel);
9832
9833 return yyrc;
9834}
9835
9836inline BOOL APIENTRY SplQmAbort(HSPL a)
9837{
9838 BOOL yyrc;
9839 USHORT sel = GetFS();
9840
9841 yyrc = SplQmAbort(a);
9842 SetFS(sel);
9843
9844 return yyrc;
9845}
9846
9847inline BOOL APIENTRY SplQmAbortDoc(HSPL a)
9848{
9849 BOOL yyrc;
9850 USHORT sel = GetFS();
9851
9852 yyrc = SplQmAbortDoc(a);
9853 SetFS(sel);
9854
9855 return yyrc;
9856}
9857
9858inline BOOL APIENTRY SplQmClose(HSPL a)
9859{
9860 BOOL yyrc;
9861 USHORT sel = GetFS();
9862
9863 yyrc = SplQmClose(a);
9864 SetFS(sel);
9865
9866 return yyrc;
9867}
9868
9869inline BOOL APIENTRY SplQmEndDoc(HSPL a)
9870{
9871 BOOL yyrc;
9872 USHORT sel = GetFS();
9873
9874 yyrc = SplQmEndDoc(a);
9875 SetFS(sel);
9876
9877 return yyrc;
9878}
9879
9880inline ULONG APIENTRY SplQmGetJobID(HSPL a, ULONG b, PVOID c, ULONG d, PULONG e)
9881{
9882 ULONG yyrc;
9883 USHORT sel = GetFS();
9884
9885 yyrc = SplQmGetJobID(a, b, c, d, e);
9886 SetFS(sel);
9887
9888 return yyrc;
9889}
9890
9891inline BOOL APIENTRY SplQmNewPage(HSPL a, ULONG b)
9892{
9893 BOOL yyrc;
9894 USHORT sel = GetFS();
9895
9896 yyrc = SplQmNewPage(a, b);
9897 SetFS(sel);
9898
9899 return yyrc;
9900}
9901
9902inline HSPL APIENTRY SplQmOpen(PSZ a, LONG b, PQMOPENDATA c)
9903{
9904 HSPL yyrc;
9905 USHORT sel = GetFS();
9906
9907 yyrc = SplQmOpen(a, b, c);
9908 SetFS(sel);
9909
9910 return yyrc;
9911}
9912
9913inline BOOL APIENTRY SplQmStartDoc(HSPL a, PSZ b)
9914{
9915 BOOL yyrc;
9916 USHORT sel = GetFS();
9917
9918 yyrc = SplQmStartDoc(a, b);
9919 SetFS(sel);
9920
9921 return yyrc;
9922}
9923
9924inline BOOL APIENTRY SplQmWrite(HSPL a, LONG b, PVOID c)
9925{
9926 BOOL yyrc;
9927 USHORT sel = GetFS();
9928
9929 yyrc = SplQmWrite(a, b, c);
9930 SetFS(sel);
9931
9932 return yyrc;
9933}
9934
9935#endif
9936#ifdef INCL_WINHELP
9937inline BOOL APIENTRY WinAssociateHelpInstance(HWND a, HWND b)
9938{
9939 BOOL yyrc;
9940 USHORT sel = GetFS();
9941
9942 yyrc = WinAssociateHelpInstance(a, b);
9943 SetFS(sel);
9944
9945 return yyrc;
9946}
9947
9948inline HWND APIENTRY WinCreateHelpInstance(HAB a, PHELPINIT b)
9949{
9950 HWND yyrc;
9951 USHORT sel = GetFS();
9952
9953 yyrc = WinCreateHelpInstance(a, b);
9954 SetFS(sel);
9955
9956 return yyrc;
9957}
9958
9959inline BOOL APIENTRY WinCreateHelpTable(HWND a, CONST HELPTABLE *b)
9960{
9961 BOOL yyrc;
9962 USHORT sel = GetFS();
9963
9964 yyrc = WinCreateHelpTable(a, b);
9965 SetFS(sel);
9966
9967 return yyrc;
9968}
9969
9970inline BOOL APIENTRY WinDestroyHelpInstance(HWND a)
9971{
9972 BOOL yyrc;
9973 USHORT sel = GetFS();
9974
9975 yyrc = WinDestroyHelpInstance(a);
9976 SetFS(sel);
9977
9978 return yyrc;
9979}
9980
9981inline BOOL APIENTRY WinLoadHelpTable(HWND a, ULONG b, HMODULE c)
9982{
9983 BOOL yyrc;
9984 USHORT sel = GetFS();
9985
9986 yyrc = WinLoadHelpTable(a, b, c);
9987 SetFS(sel);
9988
9989 return yyrc;
9990}
9991
9992inline HWND APIENTRY WinQueryHelpInstance(HWND a)
9993{
9994 HWND yyrc;
9995 USHORT sel = GetFS();
9996
9997 yyrc = WinQueryHelpInstance(a);
9998 SetFS(sel);
9999
10000 return yyrc;
10001}
10002
10003#endif
10004#ifdef INCL_DDF
10005inline BOOL APIENTRY DdfBeginList(HDDF a, ULONG b, ULONG c, ULONG d)
10006{
10007 BOOL yyrc;
10008 USHORT sel = GetFS();
10009
10010 yyrc = DdfBeginList(a, b, c, d);
10011 SetFS(sel);
10012
10013 return yyrc;
10014}
10015
10016inline BOOL APIENTRY DdfBitmap(HDDF a, HBITMAP b, ULONG c)
10017{
10018 BOOL yyrc;
10019 USHORT sel = GetFS();
10020
10021 yyrc = DdfBitmap(a, b, c);
10022 SetFS(sel);
10023
10024 return yyrc;
10025}
10026
10027inline BOOL APIENTRY DdfEndList(HDDF a)
10028{
10029 BOOL yyrc;
10030 USHORT sel = GetFS();
10031
10032 yyrc = DdfEndList(a);
10033 SetFS(sel);
10034
10035 return yyrc;
10036}
10037
10038inline BOOL APIENTRY DdfHyperText(HDDF a, PCSZ b, PCSZ c, ULONG d)
10039{
10040 BOOL yyrc;
10041 USHORT sel = GetFS();
10042
10043 yyrc = DdfHyperText(a, b, c, d);
10044 SetFS(sel);
10045
10046 return yyrc;
10047}
10048
10049inline BOOL APIENTRY DdfInform(HDDF a, PCSZ b, ULONG c)
10050{
10051 BOOL yyrc;
10052 USHORT sel = GetFS();
10053
10054 yyrc = DdfInform(a, b, c);
10055 SetFS(sel);
10056
10057 return yyrc;
10058}
10059
10060inline HDDF APIENTRY DdfInitialize(HWND a, ULONG b, ULONG c)
10061{
10062 HDDF yyrc;
10063 USHORT sel = GetFS();
10064
10065 yyrc = DdfInitialize(a, b, c);
10066 SetFS(sel);
10067
10068 return yyrc;
10069}
10070
10071inline BOOL APIENTRY DdfListItem(HDDF a, PCSZ b, PCSZ c)
10072{
10073 BOOL yyrc;
10074 USHORT sel = GetFS();
10075
10076 yyrc = DdfListItem(a, b, c);
10077 SetFS(sel);
10078
10079 return yyrc;
10080}
10081
10082inline BOOL APIENTRY DdfMetafile(HDDF a, HMF b, CONST RECTL *c)
10083{
10084 BOOL yyrc;
10085 USHORT sel = GetFS();
10086
10087 yyrc = DdfMetafile(a, b, c);
10088 SetFS(sel);
10089
10090 return yyrc;
10091}
10092
10093inline BOOL APIENTRY DdfPara(HDDF a)
10094{
10095 BOOL yyrc;
10096 USHORT sel = GetFS();
10097
10098 yyrc = DdfPara(a);
10099 SetFS(sel);
10100
10101 return yyrc;
10102}
10103
10104inline BOOL APIENTRY DdfSetColor(HDDF a, COLOR b, COLOR c)
10105{
10106 BOOL yyrc;
10107 USHORT sel = GetFS();
10108
10109 yyrc = DdfSetColor(a, b, c);
10110 SetFS(sel);
10111
10112 return yyrc;
10113}
10114
10115inline BOOL APIENTRY DdfSetFont(HDDF a, PCSZ b, ULONG c, ULONG d)
10116{
10117 BOOL yyrc;
10118 USHORT sel = GetFS();
10119
10120 yyrc = DdfSetFont(a, b, c, d);
10121 SetFS(sel);
10122
10123 return yyrc;
10124}
10125
10126inline BOOL APIENTRY DdfSetFontStyle(HDDF a, ULONG b)
10127{
10128 BOOL yyrc;
10129 USHORT sel = GetFS();
10130
10131 yyrc = DdfSetFontStyle(a, b);
10132 SetFS(sel);
10133
10134 return yyrc;
10135}
10136
10137inline BOOL APIENTRY DdfSetFormat(HDDF a, ULONG b)
10138{
10139 BOOL yyrc;
10140 USHORT sel = GetFS();
10141
10142 yyrc = DdfSetFormat(a, b);
10143 SetFS(sel);
10144
10145 return yyrc;
10146}
10147
10148inline BOOL APIENTRY DdfSetTextAlign(HDDF a, ULONG b)
10149{
10150 BOOL yyrc;
10151 USHORT sel = GetFS();
10152
10153 yyrc = DdfSetTextAlign(a, b);
10154 SetFS(sel);
10155
10156 return yyrc;
10157}
10158
10159inline BOOL APIENTRY DdfText(HDDF a, PCSZ b)
10160{
10161 BOOL yyrc;
10162 USHORT sel = GetFS();
10163
10164 yyrc = DdfText(a, b);
10165 SetFS(sel);
10166
10167 return yyrc;
10168}
10169
10170#endif
10171#ifdef INCL_AVIO
10172inline USHORT APIENTRY VioAssociate(HDC a, HVPS b)
10173{
10174 USHORT yyrc;
10175 USHORT sel = GetFS();
10176
10177 yyrc = VioAssociate(a, b);
10178 SetFS(sel);
10179
10180 return yyrc;
10181}
10182
10183inline USHORT APIENTRY16 VioCreateLogFont(PFATTRS a, LONG b, PSTR8 c, HVPS d)
10184{
10185 USHORT yyrc;
10186 USHORT sel = GetFS();
10187
10188 yyrc = VioCreateLogFont(a, b, c, d);
10189 SetFS(sel);
10190
10191 return yyrc;
10192}
10193
10194inline USHORT APIENTRY16 VioCreatePS(PHVPS a, SHORT b, SHORT c, SHORT d, SHORT e, HVPS f)
10195{
10196 USHORT yyrc;
10197 USHORT sel = GetFS();
10198
10199 yyrc = VioCreatePS(a, b, c, d, e, f);
10200 SetFS(sel);
10201
10202 return yyrc;
10203}
10204
10205inline USHORT APIENTRY16 VioDeleteSetId(LONG a, HVPS b)
10206{
10207 USHORT yyrc;
10208 USHORT sel = GetFS();
10209
10210 yyrc = VioDeleteSetId(a, b);
10211 SetFS(sel);
10212
10213 return yyrc;
10214}
10215
10216inline USHORT APIENTRY16 VioDestroyPS(HVPS a)
10217{
10218 USHORT yyrc;
10219 USHORT sel = GetFS();
10220
10221 yyrc = VioDestroyPS(a);
10222 SetFS(sel);
10223
10224 return yyrc;
10225}
10226
10227inline USHORT APIENTRY16 VioGetDeviceCellSize(PSHORT a, PSHORT b, HVPS c)
10228{
10229 USHORT yyrc;
10230 USHORT sel = GetFS();
10231
10232 yyrc = VioGetDeviceCellSize(a, b, c);
10233 SetFS(sel);
10234
10235 return yyrc;
10236}
10237
10238inline USHORT APIENTRY16 VioGetOrg(PSHORT a, PSHORT b, HVPS c)
10239{
10240 USHORT yyrc;
10241 USHORT sel = GetFS();
10242
10243 yyrc = VioGetOrg(a, b, c);
10244 SetFS(sel);
10245
10246 return yyrc;
10247}
10248
10249inline USHORT APIENTRY16 VioQueryFonts(PLONG a, PFONTMETRICS b, LONG c, PLONG d, PSZ e, ULONG f, HVPS g)
10250{
10251 USHORT yyrc;
10252 USHORT sel = GetFS();
10253
10254 yyrc = VioQueryFonts(a, b, c, d, e, f, g);
10255 SetFS(sel);
10256
10257 return yyrc;
10258}
10259
10260inline USHORT APIENTRY16 VioQuerySetIds(PLONG a, PSTR8 b, PLONG c, LONG d, HVPS e)
10261{
10262 USHORT yyrc;
10263 USHORT sel = GetFS();
10264
10265 yyrc = VioQuerySetIds(a, b, c, d, e);
10266 SetFS(sel);
10267
10268 return yyrc;
10269}
10270
10271inline USHORT APIENTRY16 VioSetDeviceCellSize(SHORT a, SHORT b, HVPS c)
10272{
10273 USHORT yyrc;
10274 USHORT sel = GetFS();
10275
10276 yyrc = VioSetDeviceCellSize(a, b, c);
10277 SetFS(sel);
10278
10279 return yyrc;
10280}
10281
10282inline USHORT APIENTRY16 VioSetOrg(SHORT a, SHORT b, HVPS c)
10283{
10284 USHORT yyrc;
10285 USHORT sel = GetFS();
10286
10287 yyrc = VioSetOrg(a, b, c);
10288 SetFS(sel);
10289
10290 return yyrc;
10291}
10292
10293inline USHORT APIENTRY16 VioShowPS(SHORT a, SHORT b, SHORT c, HVPS d)
10294{
10295 USHORT yyrc;
10296 USHORT sel = GetFS();
10297
10298 yyrc = VioShowPS(a, b, c, d);
10299 SetFS(sel);
10300
10301 return yyrc;
10302}
10303
10304inline MRESULT APIENTRY16 WinDefAVioWindowProc(HWND a, USHORT b, ULONG c, ULONG d)
10305{
10306 MRESULT yyrc;
10307 USHORT sel = GetFS();
10308
10309 yyrc = WinDefAVioWindowProc(a, b, c, d);
10310 SetFS(sel);
10311
10312 return yyrc;
10313}
10314
10315#endif
10316#ifdef INCL_KBD
10317inline USHORT APIENTRY KbdCharIn(PKBDKEYINFO a, USHORT b, HKBD c)
10318{
10319 USHORT yyrc;
10320 USHORT sel = GetFS();
10321
10322 yyrc = KbdCharIn(a, b, c);
10323 SetFS(sel);
10324
10325 return yyrc;
10326}
10327
10328inline USHORT APIENTRY16 KbdClose(HKBD a)
10329{
10330 USHORT yyrc;
10331 USHORT sel = GetFS();
10332
10333 yyrc = KbdClose(a);
10334 SetFS(sel);
10335
10336 return yyrc;
10337}
10338
10339inline USHORT APIENTRY16 KbdDeRegister()
10340{
10341 USHORT yyrc;
10342 USHORT sel = GetFS();
10343
10344 yyrc = KbdDeRegister();
10345 SetFS(sel);
10346
10347 return yyrc;
10348}
10349
10350inline USHORT APIENTRY16 KbdFlushBuffer(HKBD a)
10351{
10352 USHORT yyrc;
10353 USHORT sel = GetFS();
10354
10355 yyrc = KbdFlushBuffer(a);
10356 SetFS(sel);
10357
10358 return yyrc;
10359}
10360
10361inline USHORT APIENTRY16 KbdFreeFocus(HKBD a)
10362{
10363 USHORT yyrc;
10364 USHORT sel = GetFS();
10365
10366 yyrc = KbdFreeFocus(a);
10367 SetFS(sel);
10368
10369 return yyrc;
10370}
10371
10372inline USHORT APIENTRY16 KbdGetCp(ULONG a, PUSHORT b, HKBD c)
10373{
10374 USHORT yyrc;
10375 USHORT sel = GetFS();
10376
10377 yyrc = KbdGetCp(a, b, c);
10378 SetFS(sel);
10379
10380 return yyrc;
10381}
10382
10383inline USHORT APIENTRY16 KbdGetFocus(USHORT a, HKBD b)
10384{
10385 USHORT yyrc;
10386 USHORT sel = GetFS();
10387
10388 yyrc = KbdGetFocus(a, b);
10389 SetFS(sel);
10390
10391 return yyrc;
10392}
10393
10394inline USHORT APIENTRY16 KbdGetHWID(PKBDHWID a, HKBD b)
10395{
10396 USHORT yyrc;
10397 USHORT sel = GetFS();
10398
10399 yyrc = KbdGetHWID(a, b);
10400 SetFS(sel);
10401
10402 return yyrc;
10403}
10404
10405inline USHORT APIENTRY16 KbdGetStatus(PKBDINFO a, HKBD b)
10406{
10407 USHORT yyrc;
10408 USHORT sel = GetFS();
10409
10410 yyrc = KbdGetStatus(a, b);
10411 SetFS(sel);
10412
10413 return yyrc;
10414}
10415
10416inline USHORT APIENTRY16 KbdOpen(PHKBD a)
10417{
10418 USHORT yyrc;
10419 USHORT sel = GetFS();
10420
10421 yyrc = KbdOpen(a);
10422 SetFS(sel);
10423
10424 return yyrc;
10425}
10426
10427inline USHORT APIENTRY16 KbdPeek(PKBDKEYINFO a, HKBD b)
10428{
10429 USHORT yyrc;
10430 USHORT sel = GetFS();
10431
10432 yyrc = KbdPeek(a, b);
10433 SetFS(sel);
10434
10435 return yyrc;
10436}
10437
10438inline USHORT APIENTRY16 KbdRegister(PCSZ a, PCSZ b, ULONG c)
10439{
10440 USHORT yyrc;
10441 USHORT sel = GetFS();
10442
10443 yyrc = KbdRegister(a, b, c);
10444 SetFS(sel);
10445
10446 return yyrc;
10447}
10448
10449inline USHORT APIENTRY16 KbdSetCp(USHORT a, USHORT b, HKBD c)
10450{
10451 USHORT yyrc;
10452 USHORT sel = GetFS();
10453
10454 yyrc = KbdSetCp(a, b, c);
10455 SetFS(sel);
10456
10457 return yyrc;
10458}
10459
10460inline USHORT APIENTRY16 KbdSetCustXt(PUSHORT a, HKBD b)
10461{
10462 USHORT yyrc;
10463 USHORT sel = GetFS();
10464
10465 yyrc = KbdSetCustXt(a, b);
10466 SetFS(sel);
10467
10468 return yyrc;
10469}
10470
10471inline USHORT APIENTRY16 KbdSetFgnd()
10472{
10473 USHORT yyrc;
10474 USHORT sel = GetFS();
10475
10476 yyrc = KbdSetFgnd();
10477 SetFS(sel);
10478
10479 return yyrc;
10480}
10481
10482inline USHORT APIENTRY16 KbdSetHWID(PKBDHWID a, HKBD b)
10483{
10484 USHORT yyrc;
10485 USHORT sel = GetFS();
10486
10487 yyrc = KbdSetHWID(a, b);
10488 SetFS(sel);
10489
10490 return yyrc;
10491}
10492
10493inline USHORT APIENTRY16 KbdSetStatus(PKBDINFO a, HKBD b)
10494{
10495 USHORT yyrc;
10496 USHORT sel = GetFS();
10497
10498 yyrc = KbdSetStatus(a, b);
10499 SetFS(sel);
10500
10501 return yyrc;
10502}
10503
10504inline USHORT APIENTRY16 KbdStringIn(PCH a, PSTRINGINBUF b, USHORT c, HKBD d)
10505{
10506 USHORT yyrc;
10507 USHORT sel = GetFS();
10508
10509 yyrc = KbdStringIn(a, b, c, d);
10510 SetFS(sel);
10511
10512 return yyrc;
10513}
10514
10515inline USHORT APIENTRY16 KbdSynch(USHORT a)
10516{
10517 USHORT yyrc;
10518 USHORT sel = GetFS();
10519
10520 yyrc = KbdSynch(a);
10521 SetFS(sel);
10522
10523 return yyrc;
10524}
10525
10526inline USHORT APIENTRY16 KbdXlate(PKBDTRANS a, HKBD b)
10527{
10528 USHORT yyrc;
10529 USHORT sel = GetFS();
10530
10531 yyrc = KbdXlate(a, b);
10532 SetFS(sel);
10533
10534 return yyrc;
10535}
10536
10537#endif
10538#ifdef INCL_VIO
10539inline USHORT APIENTRY16 VioCheckCharType(PUSHORT a, USHORT b, USHORT c, HVIO d)
10540{
10541 USHORT yyrc;
10542 USHORT sel = GetFS();
10543
10544 yyrc = VioCheckCharType(a, b, c, d);
10545 SetFS(sel);
10546
10547 return yyrc;
10548}
10549
10550inline USHORT APIENTRY16 VioDeRegister()
10551{
10552 USHORT yyrc;
10553 USHORT sel = GetFS();
10554
10555 yyrc = VioDeRegister();
10556 SetFS(sel);
10557
10558 return yyrc;
10559}
10560
10561inline USHORT APIENTRY16 VioEndPopUp(HVIO a)
10562{
10563 USHORT yyrc;
10564 USHORT sel = GetFS();
10565
10566 yyrc = VioEndPopUp(a);
10567 SetFS(sel);
10568
10569 return yyrc;
10570}
10571
10572inline USHORT APIENTRY16 VioGetAnsi(PUSHORT a, HVIO b)
10573{
10574 USHORT yyrc;
10575 USHORT sel = GetFS();
10576
10577 yyrc = VioGetAnsi(a, b);
10578 SetFS(sel);
10579
10580 return yyrc;
10581}
10582
10583inline USHORT APIENTRY16 VioGetBuf(PULONG a, PUSHORT b, HVIO c)
10584{
10585 USHORT yyrc;
10586 USHORT sel = GetFS();
10587
10588 yyrc = VioGetBuf(a, b, c);
10589 SetFS(sel);
10590
10591 return yyrc;
10592}
10593
10594inline USHORT APIENTRY16 VioGetConfig(USHORT a, PVIOCONFIGINFO b, HVIO c)
10595{
10596 USHORT yyrc;
10597 USHORT sel = GetFS();
10598
10599 yyrc = VioGetConfig(a, b, c);
10600 SetFS(sel);
10601
10602 return yyrc;
10603}
10604
10605inline USHORT APIENTRY16 VioGetCp(USHORT a, PUSHORT b, HVIO c)
10606{
10607 USHORT yyrc;
10608 USHORT sel = GetFS();
10609
10610 yyrc = VioGetCp(a, b, c);
10611 SetFS(sel);
10612
10613 return yyrc;
10614}
10615
10616inline USHORT APIENTRY16 VioGetCurPos(PUSHORT a, PUSHORT b, HVIO c)
10617{
10618 USHORT yyrc;
10619 USHORT sel = GetFS();
10620
10621 yyrc = VioGetCurPos(a, b, c);
10622 SetFS(sel);
10623
10624 return yyrc;
10625}
10626
10627inline USHORT APIENTRY16 VioGetCurType(PVIOCURSORINFO a, HVIO b)
10628{
10629 USHORT yyrc;
10630 USHORT sel = GetFS();
10631
10632 yyrc = VioGetCurType(a, b);
10633 SetFS(sel);
10634
10635 return yyrc;
10636}
10637
10638inline USHORT APIENTRY16 VioGetFont(PVIOFONTINFO a, HVIO b)
10639{
10640 USHORT yyrc;
10641 USHORT sel = GetFS();
10642
10643 yyrc = VioGetFont(a, b);
10644 SetFS(sel);
10645
10646 return yyrc;
10647}
10648
10649inline USHORT APIENTRY16 VioGetMode(PVIOMODEINFO a, HVIO b)
10650{
10651 USHORT yyrc;
10652 USHORT sel = GetFS();
10653
10654 yyrc = VioGetMode(a, b);
10655 SetFS(sel);
10656
10657 return yyrc;
10658}
10659
10660inline USHORT APIENTRY16 VioGetPhysBuf(PVIOPHYSBUF a, USHORT b)
10661{
10662 USHORT yyrc;
10663 USHORT sel = GetFS();
10664
10665 yyrc = VioGetPhysBuf(a, b);
10666 SetFS(sel);
10667
10668 return yyrc;
10669}
10670
10671inline USHORT APIENTRY16 VioGetState(PVOID a, HVIO b)
10672{
10673 USHORT yyrc;
10674 USHORT sel = GetFS();
10675
10676 yyrc = VioGetState(a, b);
10677 SetFS(sel);
10678
10679 return yyrc;
10680}
10681
10682inline USHORT APIENTRY16 VioGlobalReg(PCSZ a, PCSZ b, ULONG c, ULONG d, USHORT e)
10683{
10684 USHORT yyrc;
10685 USHORT sel = GetFS();
10686
10687 yyrc = VioGlobalReg(a, b, c, d, e);
10688 SetFS(sel);
10689
10690 return yyrc;
10691}
10692
10693inline USHORT APIENTRY16 VioModeUndo(USHORT a, USHORT b, USHORT c)
10694{
10695 USHORT yyrc;
10696 USHORT sel = GetFS();
10697
10698 yyrc = VioModeUndo(a, b, c);
10699 SetFS(sel);
10700
10701 return yyrc;
10702}
10703
10704inline USHORT APIENTRY16 VioModeWait(USHORT a, PUSHORT b, USHORT c)
10705{
10706 USHORT yyrc;
10707 USHORT sel = GetFS();
10708
10709 yyrc = VioModeWait(a, b, c);
10710 SetFS(sel);
10711
10712 return yyrc;
10713}
10714
10715inline USHORT APIENTRY16 VioPopUp(PUSHORT a, HVIO b)
10716{
10717 USHORT yyrc;
10718 USHORT sel = GetFS();
10719
10720 yyrc = VioPopUp(a, b);
10721 SetFS(sel);
10722
10723 return yyrc;
10724}
10725
10726inline USHORT APIENTRY16 VioPrtSc(HVIO a)
10727{
10728 USHORT yyrc;
10729 USHORT sel = GetFS();
10730
10731 yyrc = VioPrtSc(a);
10732 SetFS(sel);
10733
10734 return yyrc;
10735}
10736
10737inline USHORT APIENTRY16 VioPrtScToggle(HVIO a)
10738{
10739 USHORT yyrc;
10740 USHORT sel = GetFS();
10741
10742 yyrc = VioPrtScToggle(a);
10743 SetFS(sel);
10744
10745 return yyrc;
10746}
10747
10748inline USHORT APIENTRY16 VioReadCellStr(PCH a, PUSHORT b, USHORT c, USHORT d, HVIO e)
10749{
10750 USHORT yyrc;
10751 USHORT sel = GetFS();
10752
10753 yyrc = VioReadCellStr(a, b, c, d, e);
10754 SetFS(sel);
10755
10756 return yyrc;
10757}
10758
10759inline USHORT APIENTRY16 VioReadCharStr(PCH a, PUSHORT b, USHORT c, USHORT d, HVIO e)
10760{
10761 USHORT yyrc;
10762 USHORT sel = GetFS();
10763
10764 yyrc = VioReadCharStr(a, b, c, d, e);
10765 SetFS(sel);
10766
10767 return yyrc;
10768}
10769
10770inline USHORT APIENTRY16 VioRegister(PCSZ a, PCSZ b, ULONG c, ULONG d)
10771{
10772 USHORT yyrc;
10773 USHORT sel = GetFS();
10774
10775 yyrc = VioRegister(a, b, c, d);
10776 SetFS(sel);
10777
10778 return yyrc;
10779}
10780
10781inline USHORT APIENTRY16 VioSavRedrawUndo(USHORT a, USHORT b, USHORT c)
10782{
10783 USHORT yyrc;
10784 USHORT sel = GetFS();
10785
10786 yyrc = VioSavRedrawUndo(a, b, c);
10787 SetFS(sel);
10788
10789 return yyrc;
10790}
10791
10792inline USHORT APIENTRY16 VioSavRedrawWait(USHORT a, PUSHORT b, USHORT c)
10793{
10794 USHORT yyrc;
10795 USHORT sel = GetFS();
10796
10797 yyrc = VioSavRedrawWait(a, b, c);
10798 SetFS(sel);
10799
10800 return yyrc;
10801}
10802
10803inline USHORT APIENTRY16 VioScrLock(USHORT a, PUCHAR b, HVIO c)
10804{
10805 USHORT yyrc;
10806 USHORT sel = GetFS();
10807
10808 yyrc = VioScrLock(a, b, c);
10809 SetFS(sel);
10810
10811 return yyrc;
10812}
10813
10814inline USHORT APIENTRY16 VioScrollDn(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
10815{
10816 USHORT yyrc;
10817 USHORT sel = GetFS();
10818
10819 yyrc = VioScrollDn(a, b, c, d, e, f, g);
10820 SetFS(sel);
10821
10822 return yyrc;
10823}
10824
10825inline USHORT APIENTRY16 VioScrollLf(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
10826{
10827 USHORT yyrc;
10828 USHORT sel = GetFS();
10829
10830 yyrc = VioScrollLf(a, b, c, d, e, f, g);
10831 SetFS(sel);
10832
10833 return yyrc;
10834}
10835
10836inline USHORT APIENTRY16 VioScrollRt(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
10837{
10838 USHORT yyrc;
10839 USHORT sel = GetFS();
10840
10841 yyrc = VioScrollRt(a, b, c, d, e, f, g);
10842 SetFS(sel);
10843
10844 return yyrc;
10845}
10846
10847inline USHORT APIENTRY16 VioScrollUp(USHORT a, USHORT b, USHORT c, USHORT d, USHORT e, PBYTE f, HVIO g)
10848{
10849 USHORT yyrc;
10850 USHORT sel = GetFS();
10851
10852 yyrc = VioScrollUp(a, b, c, d, e, f, g);
10853 SetFS(sel);
10854
10855 return yyrc;
10856}
10857
10858inline USHORT APIENTRY16 VioScrUnLock(HVIO a)
10859{
10860 USHORT yyrc;
10861 USHORT sel = GetFS();
10862
10863 yyrc = VioScrUnLock(a);
10864 SetFS(sel);
10865
10866 return yyrc;
10867}
10868
10869inline USHORT APIENTRY16 VioSetAnsi(USHORT a, HVIO b)
10870{
10871 USHORT yyrc;
10872 USHORT sel = GetFS();
10873
10874 yyrc = VioSetAnsi(a, b);
10875 SetFS(sel);
10876
10877 return yyrc;
10878}
10879
10880inline USHORT APIENTRY16 VioSetCp(USHORT a, USHORT b, HVIO c)
10881{
10882 USHORT yyrc;
10883 USHORT sel = GetFS();
10884
10885 yyrc = VioSetCp(a, b, c);
10886 SetFS(sel);
10887
10888 return yyrc;
10889}
10890
10891inline USHORT APIENTRY16 VioSetCurPos(USHORT a, USHORT b, HVIO c)
10892{
10893 USHORT yyrc;
10894 USHORT sel = GetFS();
10895
10896 yyrc = VioSetCurPos(a, b, c);
10897 SetFS(sel);
10898
10899 return yyrc;
10900}
10901
10902inline USHORT APIENTRY16 VioSetCurType(PVIOCURSORINFO a, HVIO b)
10903{
10904 USHORT yyrc;
10905 USHORT sel = GetFS();
10906
10907 yyrc = VioSetCurType(a, b);
10908 SetFS(sel);
10909
10910 return yyrc;
10911}
10912
10913inline USHORT APIENTRY16 VioSetFont(PVIOFONTINFO a, HVIO b)
10914{
10915 USHORT yyrc;
10916 USHORT sel = GetFS();
10917
10918 yyrc = VioSetFont(a, b);
10919 SetFS(sel);
10920
10921 return yyrc;
10922}
10923
10924inline USHORT APIENTRY16 VioSetMode(PVIOMODEINFO a, HVIO b)
10925{
10926 USHORT yyrc;
10927 USHORT sel = GetFS();
10928
10929 yyrc = VioSetMode(a, b);
10930 SetFS(sel);
10931
10932 return yyrc;
10933}
10934
10935inline USHORT APIENTRY16 VioSetState(PVOID a, HVIO b)
10936{
10937 USHORT yyrc;
10938 USHORT sel = GetFS();
10939
10940 yyrc = VioSetState(a, b);
10941 SetFS(sel);
10942
10943 return yyrc;
10944}
10945
10946inline USHORT APIENTRY16 VioShowBuf(USHORT a, USHORT b, HVIO c)
10947{
10948 USHORT yyrc;
10949 USHORT sel = GetFS();
10950
10951 yyrc = VioShowBuf(a, b, c);
10952 SetFS(sel);
10953
10954 return yyrc;
10955}
10956
10957inline USHORT APIENTRY16 VioWrtCellStr(PCH a, USHORT b, USHORT c, USHORT d, HVIO e)
10958{
10959 USHORT yyrc;
10960 USHORT sel = GetFS();
10961
10962 yyrc = VioWrtCellStr(a, b, c, d, e);
10963 SetFS(sel);
10964
10965 return yyrc;
10966}
10967
10968inline USHORT APIENTRY16 VioWrtCharStr(PCH a, USHORT b, USHORT c, USHORT d, HVIO e)
10969{
10970 USHORT yyrc;
10971 USHORT sel = GetFS();
10972
10973 yyrc = VioWrtCharStr(a, b, c, d, e);
10974 SetFS(sel);
10975
10976 return yyrc;
10977}
10978
10979inline USHORT APIENTRY16 VioWrtCharStrAtt(PCH a, USHORT b, USHORT c, USHORT d, PBYTE e, HVIO f)
10980{
10981 USHORT yyrc;
10982 USHORT sel = GetFS();
10983
10984 yyrc = VioWrtCharStrAtt(a, b, c, d, e, f);
10985 SetFS(sel);
10986
10987 return yyrc;
10988}
10989
10990inline USHORT APIENTRY16 VioWrtNAttr(CONST BYTE *a, USHORT b, USHORT c, USHORT d, HVIO e)
10991{
10992 USHORT yyrc;
10993 USHORT sel = GetFS();
10994
10995 yyrc = VioWrtNAttr(a, b, c, d, e);
10996 SetFS(sel);
10997
10998 return yyrc;
10999}
11000
11001inline USHORT APIENTRY16 VioWrtNCell(CONST BYTE *a, USHORT b, USHORT c, USHORT d, HVIO e)
11002{
11003 USHORT yyrc;
11004 USHORT sel = GetFS();
11005
11006 yyrc = VioWrtNCell(a, b, c, d, e);
11007 SetFS(sel);
11008
11009 return yyrc;
11010}
11011
11012inline USHORT APIENTRY16 VioWrtNChar(PCH a, USHORT b, USHORT c, USHORT d, HVIO e)
11013{
11014 USHORT yyrc;
11015 USHORT sel = GetFS();
11016
11017 yyrc = VioWrtNChar(a, b, c, d, e);
11018 SetFS(sel);
11019
11020 return yyrc;
11021}
11022
11023inline USHORT APIENTRY16 VioWrtTTY(PCH a, USHORT b, HVIO c)
11024{
11025 USHORT yyrc;
11026 USHORT sel = GetFS();
11027
11028 yyrc = VioWrtTTY(a, b, c);
11029 SetFS(sel);
11030
11031 return yyrc;
11032}
11033
11034#endif
11035#ifdef INCL_MOU
11036inline USHORT APIENTRY16 MouClose(HMOU a)
11037{
11038 USHORT yyrc;
11039 USHORT sel = GetFS();
11040
11041 yyrc = MouClose(a);
11042 SetFS(sel);
11043
11044 return yyrc;
11045}
11046
11047inline USHORT APIENTRY16 MouDeRegister()
11048{
11049 USHORT yyrc;
11050 USHORT sel = GetFS();
11051
11052 yyrc = MouDeRegister();
11053 SetFS(sel);
11054
11055 return yyrc;
11056}
11057
11058inline USHORT APIENTRY16 MouDrawPtr(HMOU a)
11059{
11060 USHORT yyrc;
11061 USHORT sel = GetFS();
11062
11063 yyrc = MouDrawPtr(a);
11064 SetFS(sel);
11065
11066 return yyrc;
11067}
11068
11069inline USHORT APIENTRY16 MouFlushQue(HMOU a)
11070{
11071 USHORT yyrc;
11072 USHORT sel = GetFS();
11073
11074 yyrc = MouFlushQue(a);
11075 SetFS(sel);
11076
11077 return yyrc;
11078}
11079
11080inline USHORT APIENTRY16 MouGetDevStatus(PUSHORT a, HMOU b)
11081{
11082 USHORT yyrc;
11083 USHORT sel = GetFS();
11084
11085 yyrc = MouGetDevStatus(a, b);
11086 SetFS(sel);
11087
11088 return yyrc;
11089}
11090
11091inline USHORT APIENTRY16 MouGetEventMask(PUSHORT a, HMOU b)
11092{
11093 USHORT yyrc;
11094 USHORT sel = GetFS();
11095
11096 yyrc = MouGetEventMask(a, b);
11097 SetFS(sel);
11098
11099 return yyrc;
11100}
11101
11102inline USHORT APIENTRY16 MouGetNumButtons(PUSHORT a, HMOU b)
11103{
11104 USHORT yyrc;
11105 USHORT sel = GetFS();
11106
11107 yyrc = MouGetNumButtons(a, b);
11108 SetFS(sel);
11109
11110 return yyrc;
11111}
11112
11113inline USHORT APIENTRY16 MouGetNumMickeys(PUSHORT a, HMOU b)
11114{
11115 USHORT yyrc;
11116 USHORT sel = GetFS();
11117
11118 yyrc = MouGetNumMickeys(a, b);
11119 SetFS(sel);
11120
11121 return yyrc;
11122}
11123
11124inline USHORT APIENTRY16 MouGetNumQueEl(PMOUQUEINFO a, HMOU b)
11125{
11126 USHORT yyrc;
11127 USHORT sel = GetFS();
11128
11129 yyrc = MouGetNumQueEl(a, b);
11130 SetFS(sel);
11131
11132 return yyrc;
11133}
11134
11135inline USHORT APIENTRY16 MouGetPtrPos(PPTRLOC a, HMOU b)
11136{
11137 USHORT yyrc;
11138 USHORT sel = GetFS();
11139
11140 yyrc = MouGetPtrPos(a, b);
11141 SetFS(sel);
11142
11143 return yyrc;
11144}
11145
11146inline USHORT APIENTRY16 MouGetPtrShape(PBYTE a, PPTRSHAPE b, HMOU c)
11147{
11148 USHORT yyrc;
11149 USHORT sel = GetFS();
11150
11151 yyrc = MouGetPtrShape(a, b, c);
11152 SetFS(sel);
11153
11154 return yyrc;
11155}
11156
11157inline USHORT APIENTRY16 MouGetScaleFact(PSCALEFACT a, HMOU b)
11158{
11159 USHORT yyrc;
11160 USHORT sel = GetFS();
11161
11162 yyrc = MouGetScaleFact(a, b);
11163 SetFS(sel);
11164
11165 return yyrc;
11166}
11167
11168inline USHORT APIENTRY16 MouGetThreshold(PTHRESHOLD a, HMOU b)
11169{
11170 USHORT yyrc;
11171 USHORT sel = GetFS();
11172
11173 yyrc = MouGetThreshold(a, b);
11174 SetFS(sel);
11175
11176 return yyrc;
11177}
11178
11179inline USHORT APIENTRY16 MouInitReal(PCSZ a)
11180{
11181 USHORT yyrc;
11182 USHORT sel = GetFS();
11183
11184 yyrc = MouInitReal(a);
11185 SetFS(sel);
11186
11187 return yyrc;
11188}
11189
11190inline USHORT APIENTRY16 MouOpen(PCSZ a, PHMOU b)
11191{
11192 USHORT yyrc;
11193 USHORT sel = GetFS();
11194
11195 yyrc = MouOpen(a, b);
11196 SetFS(sel);
11197
11198 return yyrc;
11199}
11200
11201inline USHORT APIENTRY16 MouReadEventQue(PMOUEVENTINFO a, PUSHORT b, HMOU c)
11202{
11203 USHORT yyrc;
11204 USHORT sel = GetFS();
11205
11206 yyrc = MouReadEventQue(a, b, c);
11207 SetFS(sel);
11208
11209 return yyrc;
11210}
11211
11212inline USHORT APIENTRY16 MouRegister(PCSZ a, PCSZ b, ULONG c)
11213{
11214 USHORT yyrc;
11215 USHORT sel = GetFS();
11216
11217 yyrc = MouRegister(a, b, c);
11218 SetFS(sel);
11219
11220 return yyrc;
11221}
11222
11223inline USHORT APIENTRY16 MouRemovePtr(PNOPTRRECT a, HMOU b)
11224{
11225 USHORT yyrc;
11226 USHORT sel = GetFS();
11227
11228 yyrc = MouRemovePtr(a, b);
11229 SetFS(sel);
11230
11231 return yyrc;
11232}
11233
11234inline USHORT APIENTRY16 MouSetDevStatus(PUSHORT a, HMOU b)
11235{
11236 USHORT yyrc;
11237 USHORT sel = GetFS();
11238
11239 yyrc = MouSetDevStatus(a, b);
11240 SetFS(sel);
11241
11242 return yyrc;
11243}
11244
11245inline USHORT APIENTRY16 MouSetEventMask(PUSHORT a, HMOU b)
11246{
11247 USHORT yyrc;
11248 USHORT sel = GetFS();
11249
11250 yyrc = MouSetEventMask(a, b);
11251 SetFS(sel);
11252
11253 return yyrc;
11254}
11255
11256inline USHORT APIENTRY16 MouSetPtrPos(PPTRLOC a, HMOU b)
11257{
11258 USHORT yyrc;
11259 USHORT sel = GetFS();
11260
11261 yyrc = MouSetPtrPos(a, b);
11262 SetFS(sel);
11263
11264 return yyrc;
11265}
11266
11267inline USHORT APIENTRY16 MouSetPtrShape(PBYTE a, PPTRSHAPE b, HMOU c)
11268{
11269 USHORT yyrc;
11270 USHORT sel = GetFS();
11271
11272 yyrc = MouSetPtrShape(a, b, c);
11273 SetFS(sel);
11274
11275 return yyrc;
11276}
11277
11278inline USHORT APIENTRY16 MouSetScaleFact(PSCALEFACT a, HMOU b)
11279{
11280 USHORT yyrc;
11281 USHORT sel = GetFS();
11282
11283 yyrc = MouSetScaleFact(a, b);
11284 SetFS(sel);
11285
11286 return yyrc;
11287}
11288
11289inline USHORT APIENTRY16 MouSetThreshold(PTHRESHOLD a, HMOU b)
11290{
11291 USHORT yyrc;
11292 USHORT sel = GetFS();
11293
11294 yyrc = MouSetThreshold(a, b);
11295 SetFS(sel);
11296
11297 return yyrc;
11298}
11299
11300inline USHORT APIENTRY16 MouSynch(USHORT a)
11301{
11302 USHORT yyrc;
11303 USHORT sel = GetFS();
11304
11305 yyrc = MouSynch(a);
11306 SetFS(sel);
11307
11308 return yyrc;
11309}
11310
11311#endif
11312
11313#endif
Note: See TracBrowser for help on using the repository browser.