source: trunk/include/os2wrap.h@ 94

Last change on this file since 94 was 94, checked in by achimha, 26 years ago

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